DevTmpFS.cpp 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335
  1. /*
  2. * Copyright (c) 2020, Liav A. <liavalb@hotmail.co.il>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/StringView.h>
  7. #include <Kernel/Devices/DeviceManagement.h>
  8. #include <Kernel/FileSystem/DevTmpFS.h>
  9. #include <Kernel/FileSystem/VirtualFileSystem.h>
  10. namespace Kernel {
  11. ErrorOr<NonnullLockRefPtr<FileSystem>> DevTmpFS::try_create()
  12. {
  13. return TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) DevTmpFS));
  14. }
  15. DevTmpFS::DevTmpFS() = default;
  16. size_t DevTmpFS::allocate_inode_index()
  17. {
  18. MutexLocker locker(m_lock);
  19. m_next_inode_index = m_next_inode_index.value() + 1;
  20. VERIFY(m_next_inode_index > 0);
  21. return 1 + m_next_inode_index.value();
  22. }
  23. DevTmpFS::~DevTmpFS() = default;
  24. ErrorOr<void> DevTmpFS::initialize()
  25. {
  26. m_root_inode = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) DevTmpFSRootDirectoryInode(*this)));
  27. return {};
  28. }
  29. Inode& DevTmpFS::root_inode()
  30. {
  31. return *m_root_inode;
  32. }
  33. DevTmpFSInode::DevTmpFSInode(DevTmpFS& fs)
  34. : Inode(fs, fs.allocate_inode_index())
  35. {
  36. }
  37. DevTmpFSInode::DevTmpFSInode(DevTmpFS& fs, MajorNumber major_number, MinorNumber minor_number)
  38. : Inode(fs, fs.allocate_inode_index())
  39. , m_major_number(major_number)
  40. , m_minor_number(minor_number)
  41. {
  42. }
  43. ErrorOr<size_t> DevTmpFSInode::read_bytes_locked(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
  44. {
  45. VERIFY_NOT_REACHED();
  46. }
  47. ErrorOr<void> DevTmpFSInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const
  48. {
  49. VERIFY_NOT_REACHED();
  50. }
  51. ErrorOr<NonnullLockRefPtr<Inode>> DevTmpFSInode::lookup(StringView)
  52. {
  53. VERIFY_NOT_REACHED();
  54. }
  55. ErrorOr<void> DevTmpFSInode::flush_metadata()
  56. {
  57. return {};
  58. }
  59. ErrorOr<size_t> DevTmpFSInode::write_bytes_locked(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
  60. {
  61. VERIFY_NOT_REACHED();
  62. }
  63. ErrorOr<NonnullLockRefPtr<Inode>> DevTmpFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
  64. {
  65. VERIFY_NOT_REACHED();
  66. }
  67. ErrorOr<void> DevTmpFSInode::add_child(Inode&, StringView, mode_t)
  68. {
  69. VERIFY_NOT_REACHED();
  70. }
  71. InodeMetadata DevTmpFSInode::metadata() const
  72. {
  73. MutexLocker locker(m_inode_lock);
  74. VERIFY((m_mode & 0777) == m_mode);
  75. InodeMetadata metadata;
  76. metadata.uid = m_uid;
  77. metadata.gid = m_gid;
  78. metadata.size = 0;
  79. metadata.mtime = TimeManagement::boot_time();
  80. switch (node_type()) {
  81. case Type::RootDirectory:
  82. metadata.inode = { fsid(), 1 };
  83. metadata.mode = 0040555;
  84. metadata.uid = 0;
  85. metadata.gid = 0;
  86. metadata.size = 0;
  87. metadata.mtime = TimeManagement::boot_time();
  88. break;
  89. case Type::Directory:
  90. metadata.inode = { fsid(), index() };
  91. metadata.mode = S_IFDIR | m_mode;
  92. break;
  93. case Type::BlockDevice:
  94. metadata.inode = { fsid(), index() };
  95. metadata.mode = S_IFBLK | m_mode;
  96. metadata.major_device = m_major_number;
  97. metadata.minor_device = m_minor_number;
  98. break;
  99. case Type::CharacterDevice:
  100. metadata.inode = { fsid(), index() };
  101. metadata.mode = S_IFCHR | m_mode;
  102. metadata.major_device = m_major_number;
  103. metadata.minor_device = m_minor_number;
  104. break;
  105. case Type::Link:
  106. metadata.inode = { fsid(), index() };
  107. metadata.mode = S_IFLNK | m_mode;
  108. break;
  109. default:
  110. VERIFY_NOT_REACHED();
  111. }
  112. return metadata;
  113. }
  114. ErrorOr<void> DevTmpFSInode::remove_child(StringView)
  115. {
  116. VERIFY_NOT_REACHED();
  117. }
  118. ErrorOr<void> DevTmpFSInode::chmod(mode_t mode)
  119. {
  120. MutexLocker locker(m_inode_lock);
  121. mode &= 0777;
  122. if (m_mode == mode)
  123. return {};
  124. m_mode = mode;
  125. return {};
  126. }
  127. ErrorOr<void> DevTmpFSInode::chown(UserID uid, GroupID gid)
  128. {
  129. MutexLocker locker(m_inode_lock);
  130. m_uid = uid;
  131. m_gid = gid;
  132. return {};
  133. }
  134. ErrorOr<void> DevTmpFSInode::truncate(u64)
  135. {
  136. return EPERM;
  137. }
  138. StringView DevTmpFSLinkInode::name() const
  139. {
  140. return m_name->view();
  141. }
  142. DevTmpFSLinkInode::~DevTmpFSLinkInode() = default;
  143. DevTmpFSLinkInode::DevTmpFSLinkInode(DevTmpFS& fs, NonnullOwnPtr<KString> name)
  144. : DevTmpFSInode(fs)
  145. , m_name(move(name))
  146. {
  147. }
  148. ErrorOr<size_t> DevTmpFSLinkInode::read_bytes_locked(off_t offset, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const
  149. {
  150. VERIFY(m_inode_lock.is_locked());
  151. VERIFY(offset == 0);
  152. VERIFY(m_link);
  153. TRY(buffer.write(m_link->characters() + offset, m_link->length()));
  154. return m_link->length();
  155. }
  156. ErrorOr<size_t> DevTmpFSLinkInode::write_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription*)
  157. {
  158. VERIFY(m_inode_lock.is_locked());
  159. auto new_string = TRY(buffer.try_copy_into_kstring(count));
  160. VERIFY(offset == 0);
  161. VERIFY(buffer.is_kernel_buffer());
  162. m_link = move(new_string);
  163. return count;
  164. }
  165. DevTmpFSDirectoryInode::DevTmpFSDirectoryInode(DevTmpFS& fs)
  166. : DevTmpFSInode(fs)
  167. {
  168. }
  169. DevTmpFSDirectoryInode::DevTmpFSDirectoryInode(DevTmpFS& fs, NonnullOwnPtr<KString> name)
  170. : DevTmpFSInode(fs)
  171. , m_name(move(name))
  172. {
  173. }
  174. DevTmpFSDirectoryInode::~DevTmpFSDirectoryInode() = default;
  175. ErrorOr<void> DevTmpFSDirectoryInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
  176. {
  177. MutexLocker locker(m_inode_lock);
  178. TRY(callback({ "."sv, identifier(), 0 }));
  179. TRY(callback({ ".."sv, identifier(), 0 }));
  180. for (auto& node : m_nodes) {
  181. InodeIdentifier identifier = { fsid(), node.index() };
  182. TRY(callback({ node.name(), identifier, 0 }));
  183. }
  184. return {};
  185. }
  186. ErrorOr<NonnullLockRefPtr<Inode>> DevTmpFSDirectoryInode::lookup(StringView name)
  187. {
  188. MutexLocker locker(m_inode_lock);
  189. for (auto& node : m_nodes) {
  190. if (node.name() == name) {
  191. return node;
  192. }
  193. }
  194. return Error::from_errno(ENOENT);
  195. }
  196. ErrorOr<void> DevTmpFSDirectoryInode::remove_child(StringView name)
  197. {
  198. MutexLocker locker(m_inode_lock);
  199. for (auto& node : m_nodes) {
  200. if (node.name() == name) {
  201. m_nodes.remove(node);
  202. return {};
  203. }
  204. }
  205. return Error::from_errno(ENOENT);
  206. }
  207. ErrorOr<NonnullLockRefPtr<Inode>> DevTmpFSDirectoryInode::create_child(StringView name, mode_t mode, dev_t device_mode, UserID, GroupID)
  208. {
  209. MutexLocker locker(m_inode_lock);
  210. for (auto& node : m_nodes) {
  211. if (node.name() == name)
  212. return Error::from_errno(EEXIST);
  213. }
  214. InodeMetadata metadata;
  215. metadata.mode = mode;
  216. if (metadata.is_directory()) {
  217. auto name_kstring = TRY(KString::try_create(name));
  218. auto new_directory_inode = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) DevTmpFSDirectoryInode(fs(), move(name_kstring))));
  219. TRY(new_directory_inode->chmod(mode));
  220. m_nodes.append(*new_directory_inode);
  221. return new_directory_inode;
  222. }
  223. if (metadata.is_device()) {
  224. auto name_kstring = TRY(KString::try_create(name));
  225. auto major = major_from_encoded_device(device_mode);
  226. auto minor = minor_from_encoded_device(device_mode);
  227. auto new_device_inode = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) DevTmpFSDeviceInode(fs(), major, minor, is_block_device(mode), move(name_kstring))));
  228. TRY(new_device_inode->chmod(mode));
  229. m_nodes.append(*new_device_inode);
  230. return new_device_inode;
  231. }
  232. if (metadata.is_symlink()) {
  233. auto name_kstring = TRY(KString::try_create(name));
  234. auto new_link_inode = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) DevTmpFSLinkInode(fs(), move(name_kstring))));
  235. TRY(new_link_inode->chmod(mode));
  236. m_nodes.append(*new_link_inode);
  237. return new_link_inode;
  238. }
  239. return EROFS;
  240. }
  241. DevTmpFSRootDirectoryInode::DevTmpFSRootDirectoryInode(DevTmpFS& fs)
  242. : DevTmpFSDirectoryInode(fs)
  243. {
  244. m_mode = 0555;
  245. }
  246. DevTmpFSRootDirectoryInode::~DevTmpFSRootDirectoryInode() = default;
  247. ErrorOr<void> DevTmpFSRootDirectoryInode::chmod(mode_t)
  248. {
  249. return EPERM;
  250. }
  251. ErrorOr<void> DevTmpFSRootDirectoryInode::chown(UserID, GroupID)
  252. {
  253. return EPERM;
  254. }
  255. DevTmpFSDeviceInode::DevTmpFSDeviceInode(DevTmpFS& fs, MajorNumber major_number, MinorNumber minor_number, bool block_device, NonnullOwnPtr<KString> name)
  256. : DevTmpFSInode(fs, major_number, minor_number)
  257. , m_name(move(name))
  258. , m_block_device(block_device)
  259. {
  260. }
  261. DevTmpFSDeviceInode::~DevTmpFSDeviceInode() = default;
  262. StringView DevTmpFSDeviceInode::name() const
  263. {
  264. return m_name->view();
  265. }
  266. ErrorOr<size_t> DevTmpFSDeviceInode::read_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
  267. {
  268. VERIFY(m_inode_lock.is_locked());
  269. VERIFY(!!description);
  270. LockRefPtr<Device> device = DeviceManagement::the().get_device(m_major_number, m_minor_number);
  271. if (!device)
  272. return Error::from_errno(ENODEV);
  273. if (!device->can_read(*description, offset))
  274. return Error::from_errno(ENOTIMPL);
  275. auto result = const_cast<Device&>(*device).read(*description, offset, buffer, count);
  276. if (result.is_error())
  277. return result;
  278. return result.value();
  279. }
  280. ErrorOr<size_t> DevTmpFSDeviceInode::write_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* description)
  281. {
  282. VERIFY(m_inode_lock.is_locked());
  283. VERIFY(!!description);
  284. LockRefPtr<Device> device = DeviceManagement::the().get_device(m_major_number, m_minor_number);
  285. if (!device)
  286. return Error::from_errno(ENODEV);
  287. if (!device->can_write(*description, offset))
  288. return Error::from_errno(ENOTIMPL);
  289. auto result = const_cast<Device&>(*device).write(*description, offset, buffer, count);
  290. if (result.is_error())
  291. return result;
  292. return result.value();
  293. }
  294. }