VirtualFileSystem.cpp 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688
  1. #include "VirtualFileSystem.h"
  2. #include "FileDescriptor.h"
  3. #include "FileSystem.h"
  4. #include <AK/FileSystemPath.h>
  5. #include <AK/StringBuilder.h>
  6. #include <AK/kmalloc.h>
  7. #include <AK/kstdio.h>
  8. #include <AK/ktime.h>
  9. #include "CharacterDevice.h"
  10. #include <LibC/errno_numbers.h>
  11. #include <Kernel/Process.h>
  12. //#define VFS_DEBUG
  13. static VFS* s_the;
  14. VFS& VFS::the()
  15. {
  16. ASSERT(s_the);
  17. return *s_the;
  18. }
  19. VFS::VFS()
  20. {
  21. #ifdef VFS_DEBUG
  22. kprintf("VFS: Constructing VFS\n");
  23. #endif
  24. s_the = this;
  25. }
  26. VFS::~VFS()
  27. {
  28. }
  29. InodeIdentifier VFS::root_inode_id() const
  30. {
  31. ASSERT(m_root_inode);
  32. return m_root_inode->identifier();
  33. }
  34. bool VFS::mount(RetainPtr<FS>&& file_system, const String& path)
  35. {
  36. ASSERT(file_system);
  37. int error;
  38. auto inode = old_resolve_path(path, root_inode_id(), error);
  39. if (!inode.is_valid()) {
  40. kprintf("VFS: mount can't resolve mount point '%s'\n", path.characters());
  41. return false;
  42. }
  43. kprintf("VFS: mounting %s{%p} at %s (inode: %u)\n", file_system->class_name(), file_system.ptr(), path.characters(), inode.index());
  44. // FIXME: check that this is not already a mount point
  45. auto mount = make<Mount>(inode, move(file_system));
  46. m_mounts.append(move(mount));
  47. return true;
  48. }
  49. bool VFS::mount_root(RetainPtr<FS>&& file_system)
  50. {
  51. if (m_root_inode) {
  52. kprintf("VFS: mount_root can't mount another root\n");
  53. return false;
  54. }
  55. auto mount = make<Mount>(InodeIdentifier(), move(file_system));
  56. auto root_inode_id = mount->guest().fs()->root_inode();
  57. auto root_inode = mount->guest().fs()->get_inode(root_inode_id);
  58. if (!root_inode->is_directory()) {
  59. kprintf("VFS: root inode (%02u:%08u) for / is not a directory :(\n", root_inode_id.fsid(), root_inode_id.index());
  60. return false;
  61. }
  62. m_root_inode = move(root_inode);
  63. kprintf("VFS: mounted root on %s{%p}\n",
  64. m_root_inode->fs().class_name(),
  65. &m_root_inode->fs());
  66. m_mounts.append(move(mount));
  67. return true;
  68. }
  69. auto VFS::find_mount_for_host(InodeIdentifier inode) -> Mount*
  70. {
  71. for (auto& mount : m_mounts) {
  72. if (mount->host() == inode)
  73. return mount.ptr();
  74. }
  75. return nullptr;
  76. }
  77. auto VFS::find_mount_for_guest(InodeIdentifier inode) -> Mount*
  78. {
  79. for (auto& mount : m_mounts) {
  80. if (mount->guest() == inode)
  81. return mount.ptr();
  82. }
  83. return nullptr;
  84. }
  85. bool VFS::is_vfs_root(InodeIdentifier inode) const
  86. {
  87. return inode == root_inode_id();
  88. }
  89. void VFS::traverse_directory_inode(Inode& dir_inode, Function<bool(const FS::DirectoryEntry&)> callback)
  90. {
  91. dir_inode.traverse_as_directory([&] (const FS::DirectoryEntry& entry) {
  92. InodeIdentifier resolved_inode;
  93. if (auto mount = find_mount_for_host(entry.inode))
  94. resolved_inode = mount->guest();
  95. else
  96. resolved_inode = entry.inode;
  97. if (dir_inode.identifier().is_root_inode() && !is_vfs_root(dir_inode.identifier()) && !strcmp(entry.name, "..")) {
  98. auto mount = find_mount_for_guest(entry.inode);
  99. ASSERT(mount);
  100. resolved_inode = mount->host();
  101. }
  102. callback(FS::DirectoryEntry(entry.name, entry.name_length, resolved_inode, entry.file_type));
  103. return true;
  104. });
  105. }
  106. RetainPtr<FileDescriptor> VFS::open(RetainPtr<Device>&& device, int& error, int options)
  107. {
  108. // FIXME: Respect options.
  109. (void) options;
  110. (void) error;
  111. return FileDescriptor::create(move(device));
  112. }
  113. KResult VFS::utime(const String& path, Inode& base, time_t atime, time_t mtime)
  114. {
  115. int error;
  116. auto descriptor = VFS::the().open(move(path), error, 0, 0, base);
  117. if (!descriptor)
  118. return KResult(error);
  119. auto& inode = *descriptor->inode();
  120. if (inode.fs().is_readonly())
  121. return KResult(-EROFS);
  122. if (inode.metadata().uid != current->euid())
  123. return KResult(-EACCES);
  124. error = inode.set_atime(atime);
  125. if (error)
  126. return KResult(error);
  127. error = inode.set_mtime(mtime);
  128. if (error)
  129. return KResult(error);
  130. return KSuccess;
  131. }
  132. bool VFS::stat(const String& path, int& error, int options, Inode& base, struct stat& statbuf)
  133. {
  134. auto inode_id = old_resolve_path(path, base.identifier(), error, options);
  135. if (!inode_id.is_valid())
  136. return false;
  137. error = FileDescriptor::create(get_inode(inode_id))->fstat(&statbuf);
  138. if (error)
  139. return false;
  140. return true;
  141. }
  142. RetainPtr<FileDescriptor> VFS::open(const String& path, int& error, int options, mode_t mode, Inode& base)
  143. {
  144. auto inode_id = old_resolve_path(path, base.identifier(), error, options);
  145. auto inode = get_inode(inode_id);
  146. if (options & O_CREAT) {
  147. if (!inode)
  148. return create(path, error, options, mode, base);
  149. else if (options & O_EXCL) {
  150. error = -EEXIST;
  151. return nullptr;
  152. }
  153. }
  154. if (!inode)
  155. return nullptr;
  156. auto metadata = inode->metadata();
  157. // NOTE: Read permission is a bit weird, since O_RDONLY == 0,
  158. // so we check if (NOT write_only OR read_and_write)
  159. if (!(options & O_WRONLY) || (options & O_RDWR)) {
  160. if (!metadata.may_read(*current)) {
  161. error = -EACCES;
  162. return nullptr;
  163. }
  164. }
  165. if ((options & O_WRONLY) || (options & O_RDWR)) {
  166. if (!metadata.may_write(*current)) {
  167. error = -EACCES;
  168. return nullptr;
  169. }
  170. }
  171. if (metadata.is_device()) {
  172. auto it = m_devices.find(encoded_device(metadata.major_device, metadata.minor_device));
  173. if (it == m_devices.end()) {
  174. kprintf("VFS::open: no such device %u,%u\n", metadata.major_device, metadata.minor_device);
  175. return nullptr;
  176. }
  177. auto descriptor = (*it).value->open(error, options);
  178. descriptor->set_original_inode(Badge<VFS>(), move(inode));
  179. return descriptor;
  180. }
  181. return FileDescriptor::create(move(inode));
  182. }
  183. RetainPtr<FileDescriptor> VFS::create(const String& path, int& error, int options, mode_t mode, Inode& base)
  184. {
  185. (void) options;
  186. error = -EWHYTHO;
  187. if (!is_socket(mode) && !is_fifo(mode) && !is_block_device(mode) && !is_character_device(mode)) {
  188. // Turn it into a regular file. (This feels rather hackish.)
  189. mode |= 0100000;
  190. }
  191. RetainPtr<Inode> parent_inode;
  192. auto existing_file = resolve_path_to_inode(path, base, error, &parent_inode);
  193. if (existing_file) {
  194. error = -EEXIST;
  195. return nullptr;
  196. }
  197. if (!parent_inode) {
  198. error = -ENOENT;
  199. return nullptr;
  200. }
  201. if (error != -ENOENT) {
  202. return nullptr;
  203. }
  204. if (!parent_inode->metadata().may_write(*current)) {
  205. error = -EACCES;
  206. return nullptr;
  207. }
  208. FileSystemPath p(path);
  209. dbgprintf("VFS::create_file: '%s' in %u:%u\n", p.basename().characters(), parent_inode->fsid(), parent_inode->index());
  210. auto new_file = parent_inode->fs().create_inode(parent_inode->identifier(), p.basename(), mode, 0, error);
  211. if (!new_file)
  212. return nullptr;
  213. error = 0;
  214. return FileDescriptor::create(move(new_file));
  215. }
  216. KResult VFS::mkdir(const String& path, mode_t mode, Inode& base)
  217. {
  218. RetainPtr<Inode> parent_inode;
  219. auto result = resolve_path_to_inode(path, base, &parent_inode);
  220. if (!result.is_error())
  221. return KResult(-EEXIST);
  222. if (!parent_inode)
  223. return KResult(-ENOENT);
  224. if (result.error() != -ENOENT)
  225. return result.error();
  226. if (!parent_inode->metadata().may_write(*current))
  227. return KResult(-EACCES);
  228. FileSystemPath p(path);
  229. dbgprintf("VFS::mkdir: '%s' in %u:%u\n", p.basename().characters(), parent_inode->fsid(), parent_inode->index());
  230. int error;
  231. auto new_dir = parent_inode->fs().create_directory(parent_inode->identifier(), p.basename(), mode, error);
  232. if (new_dir)
  233. return KSuccess;
  234. return KResult(error);
  235. }
  236. KResult VFS::access(const String& path, int mode, Inode& base)
  237. {
  238. auto inode_or_error = resolve_path_to_inode(path, base);
  239. if (inode_or_error.is_error())
  240. return inode_or_error.error();
  241. auto inode = inode_or_error.value();
  242. auto metadata = inode->metadata();
  243. if (mode & R_OK) {
  244. if (!metadata.may_read(*current))
  245. return KResult(-EACCES);
  246. }
  247. if (mode & W_OK) {
  248. if (!metadata.may_write(*current))
  249. return KResult(-EACCES);
  250. }
  251. if (mode & X_OK) {
  252. if (!metadata.may_execute(*current))
  253. return KResult(-EACCES);
  254. }
  255. return KSuccess;
  256. }
  257. KResult VFS::chmod(const String& path, mode_t mode, Inode& base)
  258. {
  259. auto inode_or_error = resolve_path_to_inode(path, base);
  260. if (inode_or_error.is_error())
  261. return inode_or_error.error();
  262. auto inode = inode_or_error.value();
  263. if (inode->fs().is_readonly())
  264. return KResult(-EROFS);
  265. // FIXME: Superuser should always be allowed to chmod.
  266. if (current->euid() != inode->metadata().uid)
  267. return KResult(-EPERM);
  268. // Only change the permission bits.
  269. mode = (inode->mode() & ~04777) | (mode & 04777);
  270. kprintf("VFS::chmod(): %u:%u mode %o\n", inode->fsid(), inode->index(), mode);
  271. return inode->chmod(mode);
  272. }
  273. KResult VFS::chown(const String& path, uid_t a_uid, gid_t a_gid, Inode& base)
  274. {
  275. auto inode_or_error = resolve_path_to_inode(path, base);
  276. if (inode_or_error.is_error())
  277. return inode_or_error.error();
  278. auto inode = inode_or_error.value();
  279. if (inode->fs().is_readonly())
  280. return KResult(-EROFS);
  281. if (current->euid() != inode->metadata().uid && !current->is_superuser())
  282. return KResult(-EPERM);
  283. uid_t new_uid = inode->metadata().uid;
  284. gid_t new_gid = inode->metadata().gid;
  285. if (a_uid != (uid_t)-1) {
  286. if (current->euid() != a_uid && !current->is_superuser())
  287. return KResult(-EPERM);
  288. new_uid = a_uid;
  289. }
  290. if (a_gid != (gid_t)-1) {
  291. if (!current->in_group(a_gid) && !current->is_superuser())
  292. return KResult(-EPERM);
  293. new_gid = a_gid;
  294. }
  295. dbgprintf("VFS::chown(): inode %u:%u <- uid:%d, gid:%d\n", inode->fsid(), inode->index(), new_uid, new_gid);
  296. return inode->chown(new_uid, new_gid);
  297. }
  298. KResultOr<RetainPtr<Inode>> VFS::resolve_path_to_inode(const String& path, Inode& base, RetainPtr<Inode>* parent_inode)
  299. {
  300. // FIXME: This won't work nicely across mount boundaries.
  301. FileSystemPath p(path);
  302. if (!p.is_valid())
  303. return KResult(-EINVAL);
  304. InodeIdentifier parent_id;
  305. auto result = resolve_path(path, base.identifier(), 0, &parent_id);
  306. if (parent_inode && parent_id.is_valid())
  307. *parent_inode = get_inode(parent_id);
  308. if (result.is_error())
  309. return result.error();
  310. return get_inode(result.value());
  311. }
  312. RetainPtr<Inode> VFS::resolve_path_to_inode(const String& path, Inode& base, int& error, RetainPtr<Inode>* parent_inode)
  313. {
  314. // FIXME: This won't work nicely across mount boundaries.
  315. FileSystemPath p(path);
  316. if (!p.is_valid()) {
  317. error = -EINVAL;
  318. return nullptr;
  319. }
  320. InodeIdentifier parent_id;
  321. auto inode_id = old_resolve_path(path, base.identifier(), error, 0, &parent_id);
  322. if (parent_inode && parent_id.is_valid())
  323. *parent_inode = get_inode(parent_id);
  324. if (!inode_id.is_valid()) {
  325. error = -ENOENT;
  326. return nullptr;
  327. }
  328. return get_inode(inode_id);
  329. }
  330. bool VFS::link(const String& old_path, const String& new_path, Inode& base, int& error)
  331. {
  332. auto old_inode = resolve_path_to_inode(old_path, base, error);
  333. if (!old_inode)
  334. return false;
  335. RetainPtr<Inode> parent_inode;
  336. auto new_inode = resolve_path_to_inode(new_path, base, error, &parent_inode);
  337. if (new_inode) {
  338. error = -EEXIST;
  339. return false;
  340. }
  341. if (!parent_inode) {
  342. error = -ENOENT;
  343. return false;
  344. }
  345. if (parent_inode->fsid() != old_inode->fsid()) {
  346. error = -EXDEV;
  347. return false;
  348. }
  349. if (parent_inode->fs().is_readonly()) {
  350. error = -EROFS;
  351. return false;
  352. }
  353. if (!parent_inode->metadata().may_write(*current)) {
  354. error = -EACCES;
  355. return false;
  356. }
  357. if (!parent_inode->add_child(old_inode->identifier(), FileSystemPath(new_path).basename(), 0, error))
  358. return false;
  359. error = 0;
  360. return true;
  361. }
  362. bool VFS::unlink(const String& path, Inode& base, int& error)
  363. {
  364. RetainPtr<Inode> parent_inode;
  365. auto inode = resolve_path_to_inode(path, base, error, &parent_inode);
  366. if (!inode)
  367. return false;
  368. if (inode->is_directory()) {
  369. error = -EISDIR;
  370. return false;
  371. }
  372. if (!parent_inode->metadata().may_write(*current)) {
  373. error = -EACCES;
  374. return false;
  375. }
  376. if (!parent_inode->remove_child(FileSystemPath(path).basename(), error))
  377. return false;
  378. error = 0;
  379. return true;
  380. }
  381. bool VFS::rmdir(const String& path, Inode& base, int& error)
  382. {
  383. error = -EWHYTHO;
  384. RetainPtr<Inode> parent_inode;
  385. auto inode = resolve_path_to_inode(path, base, error, &parent_inode);
  386. if (!inode)
  387. return false;
  388. if (inode->fs().is_readonly()) {
  389. error = -EROFS;
  390. return false;
  391. }
  392. // FIXME: We should return EINVAL if the last component of the path is "."
  393. // FIXME: We should return ENOTEMPTY if the last component of the path is ".."
  394. if (!inode->is_directory()) {
  395. error = -ENOTDIR;
  396. return false;
  397. }
  398. if (!parent_inode->metadata().may_write(*current)) {
  399. error = -EACCES;
  400. return false;
  401. }
  402. if (inode->directory_entry_count() != 2) {
  403. error = -ENOTEMPTY;
  404. return false;
  405. }
  406. dbgprintf("VFS::rmdir: Removing inode %u:%u from parent %u:%u\n", inode->fsid(), inode->index(), parent_inode->fsid(), parent_inode->index());
  407. // To do:
  408. // - Remove '.' in target (--child.link_count)
  409. // - Remove '..' in target (--parent.link_count)
  410. // - Remove target from its parent (--parent.link_count)
  411. if (!inode->remove_child(".", error))
  412. return false;
  413. if (!inode->remove_child("..", error))
  414. return false;
  415. // FIXME: The reverse_lookup here can definitely be avoided.
  416. if (!parent_inode->remove_child(parent_inode->reverse_lookup(inode->identifier()), error))
  417. return false;
  418. error = 0;
  419. return true;
  420. }
  421. KResultOr<InodeIdentifier> VFS::resolve_symbolic_link(InodeIdentifier base, Inode& symlink_inode)
  422. {
  423. auto symlink_contents = symlink_inode.read_entire();
  424. if (!symlink_contents)
  425. return KResult(-ENOENT);
  426. auto linkee = String((const char*)symlink_contents.pointer(), symlink_contents.size());
  427. #ifdef VFS_DEBUG
  428. kprintf("linkee (%s)(%u) from %u:%u\n", linkee.characters(), linkee.length(), base.fsid(), base.index());
  429. #endif
  430. return resolve_path(linkee, base);
  431. }
  432. RetainPtr<Inode> VFS::get_inode(InodeIdentifier inode_id)
  433. {
  434. if (!inode_id.is_valid())
  435. return nullptr;
  436. return inode_id.fs()->get_inode(inode_id);
  437. }
  438. String VFS::absolute_path(InodeIdentifier inode_id)
  439. {
  440. auto inode = get_inode(inode_id);
  441. if (!inode)
  442. return { };
  443. return absolute_path(*inode);
  444. }
  445. String VFS::absolute_path(Inode& core_inode)
  446. {
  447. int error;
  448. Vector<InodeIdentifier> lineage;
  449. RetainPtr<Inode> inode = &core_inode;
  450. while (inode->identifier() != root_inode_id()) {
  451. if (auto* mount = find_mount_for_guest(inode->identifier()))
  452. lineage.append(mount->host());
  453. else
  454. lineage.append(inode->identifier());
  455. InodeIdentifier parent_id;
  456. if (inode->is_directory()) {
  457. parent_id = old_resolve_path("..", inode->identifier(), error);
  458. } else {
  459. parent_id = inode->parent()->identifier();
  460. }
  461. ASSERT(parent_id.is_valid());
  462. inode = get_inode(parent_id);
  463. }
  464. if (lineage.is_empty())
  465. return "/";
  466. lineage.append(root_inode_id());
  467. StringBuilder builder;
  468. for (size_t i = lineage.size() - 1; i >= 1; --i) {
  469. auto& child = lineage[i - 1];
  470. auto parent = lineage[i];
  471. if (auto* mount = find_mount_for_host(parent))
  472. parent = mount->guest();
  473. builder.append('/');
  474. auto parent_inode = get_inode(parent);
  475. builder.append(parent_inode->reverse_lookup(child));
  476. }
  477. return builder.to_string();
  478. }
  479. KResultOr<InodeIdentifier> VFS::resolve_path(const String& path, InodeIdentifier base, int options, InodeIdentifier* parent_id)
  480. {
  481. if (path.is_empty())
  482. return KResult(-EINVAL);
  483. auto parts = path.split('/');
  484. InodeIdentifier crumb_id;
  485. if (path[0] == '/')
  486. crumb_id = root_inode_id();
  487. else
  488. crumb_id = base.is_valid() ? base : root_inode_id();
  489. if (parent_id)
  490. *parent_id = crumb_id;
  491. for (int i = 0; i < parts.size(); ++i) {
  492. bool inode_was_root_at_head_of_loop = crumb_id.is_root_inode();
  493. auto& part = parts[i];
  494. if (part.is_empty())
  495. break;
  496. auto crumb_inode = get_inode(crumb_id);
  497. if (!crumb_inode) {
  498. #ifdef VFS_DEBUG
  499. kprintf("invalid metadata\n");
  500. #endif
  501. return KResult(-EIO);
  502. }
  503. auto metadata = crumb_inode->metadata();
  504. if (!metadata.is_directory()) {
  505. #ifdef VFS_DEBUG
  506. kprintf("parent of <%s> not directory, it's inode %u:%u / %u:%u, mode: %u, size: %u\n", part.characters(), crumb_id.fsid(), crumb_id.index(), metadata.inode.fsid(), metadata.inode.index(), metadata.mode, metadata.size);
  507. #endif
  508. return KResult(-ENOTDIR);
  509. }
  510. if (!metadata.may_execute(*current))
  511. return KResult(-EACCES);
  512. auto parent = crumb_id;
  513. crumb_id = crumb_inode->lookup(part);
  514. if (!crumb_id.is_valid()) {
  515. #ifdef VFS_DEBUG
  516. kprintf("child <%s>(%u) not found in directory, %02u:%08u\n", part.characters(), part.length(), parent.fsid(), parent.index());
  517. #endif
  518. return KResult(-ENOENT);
  519. }
  520. #ifdef VFS_DEBUG
  521. kprintf("<%s> %u:%u\n", part.characters(), crumb_id.fsid(), crumb_id.index());
  522. #endif
  523. if (auto mount = find_mount_for_host(crumb_id)) {
  524. #ifdef VFS_DEBUG
  525. kprintf(" -- is host\n");
  526. #endif
  527. crumb_id = mount->guest();
  528. }
  529. if (inode_was_root_at_head_of_loop && crumb_id.is_root_inode() && !is_vfs_root(crumb_id) && part == "..") {
  530. #ifdef VFS_DEBUG
  531. kprintf(" -- is guest\n");
  532. #endif
  533. auto mount = find_mount_for_guest(crumb_id);
  534. auto dir_inode = get_inode(mount->host());
  535. ASSERT(dir_inode);
  536. crumb_id = dir_inode->lookup("..");
  537. }
  538. crumb_inode = get_inode(crumb_id);
  539. ASSERT(crumb_inode);
  540. metadata = crumb_inode->metadata();
  541. if (metadata.is_directory()) {
  542. if (i != parts.size() - 1) {
  543. if (parent_id)
  544. *parent_id = crumb_id;
  545. }
  546. }
  547. if (metadata.is_symlink()) {
  548. if (i == parts.size() - 1) {
  549. if (options & O_NOFOLLOW)
  550. return KResult(-ELOOP);
  551. if (options & O_NOFOLLOW_NOERROR)
  552. return crumb_id;
  553. }
  554. auto result = resolve_symbolic_link(parent, *crumb_inode);
  555. if (result.is_error())
  556. return KResult(-ENOENT);
  557. crumb_id = result.value();
  558. ASSERT(crumb_id.is_valid());
  559. }
  560. }
  561. return crumb_id;
  562. }
  563. InodeIdentifier VFS::old_resolve_path(const String& path, InodeIdentifier base, int& error, int options, InodeIdentifier* parent_id)
  564. {
  565. auto result = resolve_path(path, base, options, parent_id);
  566. if (result.is_error()) {
  567. error = result.error();
  568. return { };
  569. }
  570. return result.value();
  571. }
  572. VFS::Mount::Mount(InodeIdentifier host, RetainPtr<FS>&& guest_fs)
  573. : m_host(host)
  574. , m_guest(guest_fs->root_inode())
  575. , m_guest_fs(move(guest_fs))
  576. {
  577. }
  578. void VFS::register_device(Device& device)
  579. {
  580. m_devices.set(encoded_device(device.major(), device.minor()), &device);
  581. }
  582. void VFS::unregister_device(Device& device)
  583. {
  584. m_devices.remove(encoded_device(device.major(), device.minor()));
  585. }
  586. Device* VFS::get_device(unsigned major, unsigned minor)
  587. {
  588. auto it = m_devices.find(encoded_device(major, minor));
  589. if (it == m_devices.end())
  590. return nullptr;
  591. return (*it).value;
  592. }
  593. void VFS::for_each_mount(Function<void(const Mount&)> callback) const
  594. {
  595. for (auto& mount : m_mounts) {
  596. callback(*mount);
  597. }
  598. }
  599. void VFS::sync()
  600. {
  601. FS::sync();
  602. }