DevFS.cpp 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372
  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/FileSystem/DevFS.h>
  8. #include <Kernel/FileSystem/VirtualFileSystem.h>
  9. namespace Kernel {
  10. KResultOr<NonnullRefPtr<DevFS>> DevFS::try_create()
  11. {
  12. return adopt_nonnull_ref_or_enomem(new (nothrow) DevFS);
  13. }
  14. DevFS::DevFS()
  15. {
  16. }
  17. size_t DevFS::allocate_inode_index()
  18. {
  19. MutexLocker locker(m_lock);
  20. m_next_inode_index = m_next_inode_index.value() + 1;
  21. VERIFY(m_next_inode_index > 0);
  22. return 1 + m_next_inode_index.value();
  23. }
  24. DevFS::~DevFS()
  25. {
  26. }
  27. KResult DevFS::initialize()
  28. {
  29. m_root_inode = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) DevFSRootDirectoryInode(*this)));
  30. return KSuccess;
  31. }
  32. Inode& DevFS::root_inode()
  33. {
  34. return *m_root_inode;
  35. }
  36. DevFSInode::DevFSInode(DevFS& fs)
  37. : Inode(fs, fs.allocate_inode_index())
  38. {
  39. }
  40. KResultOr<size_t> DevFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
  41. {
  42. VERIFY_NOT_REACHED();
  43. }
  44. KResult DevFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
  45. {
  46. VERIFY_NOT_REACHED();
  47. }
  48. KResultOr<NonnullRefPtr<Inode>> DevFSInode::lookup(StringView)
  49. {
  50. VERIFY_NOT_REACHED();
  51. }
  52. void DevFSInode::flush_metadata()
  53. {
  54. }
  55. KResultOr<size_t> DevFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
  56. {
  57. VERIFY_NOT_REACHED();
  58. }
  59. KResultOr<NonnullRefPtr<Inode>> DevFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
  60. {
  61. return EROFS;
  62. }
  63. KResult DevFSInode::add_child(Inode&, const StringView&, mode_t)
  64. {
  65. return EROFS;
  66. }
  67. KResult DevFSInode::remove_child(const StringView&)
  68. {
  69. return EROFS;
  70. }
  71. KResult DevFSInode::chmod(mode_t)
  72. {
  73. return EPERM;
  74. }
  75. KResult DevFSInode::chown(UserID, GroupID)
  76. {
  77. return EPERM;
  78. }
  79. KResult DevFSInode::truncate(u64)
  80. {
  81. return EPERM;
  82. }
  83. StringView DevFSLinkInode::name() const
  84. {
  85. return m_name->view();
  86. }
  87. DevFSLinkInode::~DevFSLinkInode()
  88. {
  89. }
  90. DevFSLinkInode::DevFSLinkInode(DevFS& fs, NonnullOwnPtr<KString> name)
  91. : DevFSInode(fs)
  92. , m_name(move(name))
  93. {
  94. }
  95. KResultOr<size_t> DevFSLinkInode::read_bytes(off_t offset, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const
  96. {
  97. MutexLocker locker(m_inode_lock);
  98. VERIFY(offset == 0);
  99. VERIFY(m_link);
  100. TRY(buffer.write(m_link->characters() + offset, m_link->length()));
  101. return m_link->length();
  102. }
  103. InodeMetadata DevFSLinkInode::metadata() const
  104. {
  105. InodeMetadata metadata;
  106. metadata.inode = { fsid(), index() };
  107. metadata.mode = S_IFLNK | 0555;
  108. metadata.uid = 0;
  109. metadata.gid = 0;
  110. metadata.size = 0;
  111. metadata.mtime = mepoch;
  112. return metadata;
  113. }
  114. KResultOr<size_t> DevFSLinkInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription*)
  115. {
  116. auto new_string = TRY(buffer.try_copy_into_kstring(count));
  117. MutexLocker locker(m_inode_lock);
  118. VERIFY(offset == 0);
  119. VERIFY(buffer.is_kernel_buffer());
  120. m_link = move(new_string);
  121. return count;
  122. }
  123. DevFSDirectoryInode::DevFSDirectoryInode(DevFS& fs)
  124. : DevFSInode(fs)
  125. {
  126. }
  127. DevFSDirectoryInode::~DevFSDirectoryInode()
  128. {
  129. }
  130. InodeMetadata DevFSDirectoryInode::metadata() const
  131. {
  132. InodeMetadata metadata;
  133. metadata.inode = { fsid(), 1 };
  134. metadata.mode = 0040555;
  135. metadata.uid = 0;
  136. metadata.gid = 0;
  137. metadata.size = 0;
  138. metadata.mtime = mepoch;
  139. return metadata;
  140. }
  141. DevFSRootDirectoryInode::DevFSRootDirectoryInode(DevFS& fs)
  142. : DevFSDirectoryInode(fs)
  143. {
  144. }
  145. KResult DevFSRootDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
  146. {
  147. MutexLocker locker(fs().m_lock);
  148. callback({ ".", identifier(), 0 });
  149. callback({ "..", identifier(), 0 });
  150. for (auto& node : m_nodes) {
  151. InodeIdentifier identifier = { fsid(), node.index() };
  152. callback({ node.name(), identifier, 0 });
  153. }
  154. return KSuccess;
  155. }
  156. KResultOr<NonnullRefPtr<Inode>> DevFSRootDirectoryInode::lookup(StringView name)
  157. {
  158. MutexLocker locker(fs().m_lock);
  159. for (auto& node : m_nodes) {
  160. if (node.name() == name)
  161. return node;
  162. }
  163. return ENOENT;
  164. }
  165. KResult DevFSRootDirectoryInode::remove_child(const StringView& name)
  166. {
  167. MutexLocker locker(fs().m_lock);
  168. for (auto& node : m_nodes) {
  169. if (node.name() == name) {
  170. m_nodes.remove(node);
  171. return KSuccess;
  172. }
  173. }
  174. return KResult(ENOENT);
  175. }
  176. KResultOr<NonnullRefPtr<Inode>> DevFSRootDirectoryInode::create_child(StringView name, mode_t mode, dev_t device_mode, UserID, GroupID)
  177. {
  178. MutexLocker locker(fs().m_lock);
  179. for (auto& node : m_nodes) {
  180. if (node.name() == name)
  181. return KResult(EEXIST);
  182. }
  183. InodeMetadata metadata;
  184. metadata.mode = mode;
  185. if (metadata.is_directory()) {
  186. if (name != "pts")
  187. return EROFS;
  188. auto new_directory_inode = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) DevFSPtsDirectoryInode(fs())));
  189. m_nodes.append(*new_directory_inode);
  190. return new_directory_inode;
  191. }
  192. if (metadata.is_device()) {
  193. auto name_kstring = TRY(KString::try_create(name));
  194. unsigned major = major_from_encoded_device(device_mode);
  195. unsigned minor = minor_from_encoded_device(device_mode);
  196. auto new_device_inode = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) DevFSDeviceInode(fs(), major, minor, is_block_device(mode), move(name_kstring))));
  197. TRY(new_device_inode->chmod(mode));
  198. m_nodes.append(*new_device_inode);
  199. return new_device_inode;
  200. }
  201. if (metadata.is_symlink()) {
  202. auto name_kstring = TRY(KString::try_create(name));
  203. auto new_link_inode = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) DevFSLinkInode(fs(), move(name_kstring))));
  204. m_nodes.append(*new_link_inode);
  205. return new_link_inode;
  206. }
  207. return EROFS;
  208. }
  209. DevFSRootDirectoryInode::~DevFSRootDirectoryInode()
  210. {
  211. }
  212. InodeMetadata DevFSRootDirectoryInode::metadata() const
  213. {
  214. InodeMetadata metadata;
  215. metadata.inode = { fsid(), 1 };
  216. metadata.mode = 0040555;
  217. metadata.uid = 0;
  218. metadata.gid = 0;
  219. metadata.size = 0;
  220. metadata.mtime = mepoch;
  221. return metadata;
  222. }
  223. DevFSDeviceInode::DevFSDeviceInode(DevFS& fs, unsigned major_number, unsigned minor_number, bool block_device, NonnullOwnPtr<KString> name)
  224. : DevFSInode(fs)
  225. , m_name(move(name))
  226. , m_major_number(major_number)
  227. , m_minor_number(minor_number)
  228. , m_block_device(block_device)
  229. {
  230. }
  231. DevFSDeviceInode::~DevFSDeviceInode()
  232. {
  233. }
  234. KResult DevFSDeviceInode::chown(UserID uid, GroupID gid)
  235. {
  236. MutexLocker locker(m_inode_lock);
  237. m_uid = uid;
  238. m_gid = gid;
  239. return KSuccess;
  240. }
  241. KResult DevFSDeviceInode::chmod(mode_t mode)
  242. {
  243. MutexLocker locker(m_inode_lock);
  244. mode &= 0777;
  245. if (m_required_mode == mode)
  246. return KSuccess;
  247. m_required_mode = mode;
  248. return KSuccess;
  249. }
  250. StringView DevFSDeviceInode::name() const
  251. {
  252. return m_name->view();
  253. }
  254. KResultOr<size_t> DevFSDeviceInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
  255. {
  256. MutexLocker locker(m_inode_lock);
  257. VERIFY(!!description);
  258. RefPtr<Device> device = Device::get_device(m_major_number, m_minor_number);
  259. if (!device)
  260. return KResult(ENODEV);
  261. if (!device->can_read(*description, offset))
  262. return KResult(ENOTIMPL);
  263. auto result = const_cast<Device&>(*device).read(*description, offset, buffer, count);
  264. if (result.is_error())
  265. return result;
  266. return result.value();
  267. }
  268. InodeMetadata DevFSDeviceInode::metadata() const
  269. {
  270. MutexLocker locker(m_inode_lock);
  271. InodeMetadata metadata;
  272. metadata.inode = { fsid(), index() };
  273. metadata.mode = (m_block_device ? S_IFBLK : S_IFCHR) | m_required_mode;
  274. metadata.uid = m_uid;
  275. metadata.gid = m_gid;
  276. metadata.size = 0;
  277. metadata.mtime = mepoch;
  278. metadata.major_device = m_major_number;
  279. metadata.minor_device = m_minor_number;
  280. return metadata;
  281. }
  282. KResultOr<size_t> DevFSDeviceInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* description)
  283. {
  284. MutexLocker locker(m_inode_lock);
  285. VERIFY(!!description);
  286. RefPtr<Device> device = Device::get_device(m_major_number, m_minor_number);
  287. if (!device)
  288. return KResult(ENODEV);
  289. if (!device->can_write(*description, offset))
  290. return KResult(ENOTIMPL);
  291. auto result = const_cast<Device&>(*device).write(*description, offset, buffer, count);
  292. if (result.is_error())
  293. return result;
  294. return result.value();
  295. }
  296. DevFSPtsDirectoryInode::DevFSPtsDirectoryInode(DevFS& fs)
  297. : DevFSDirectoryInode(fs)
  298. {
  299. }
  300. KResult DevFSPtsDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
  301. {
  302. MutexLocker locker(m_inode_lock);
  303. callback({ ".", identifier(), 0 });
  304. callback({ "..", identifier(), 0 });
  305. return KSuccess;
  306. }
  307. KResultOr<NonnullRefPtr<Inode>> DevFSPtsDirectoryInode::lookup(StringView)
  308. {
  309. return ENOENT;
  310. }
  311. DevFSPtsDirectoryInode::~DevFSPtsDirectoryInode()
  312. {
  313. }
  314. InodeMetadata DevFSPtsDirectoryInode::metadata() const
  315. {
  316. InodeMetadata metadata;
  317. metadata.inode = { fsid(), index() };
  318. metadata.mode = 0040555;
  319. metadata.uid = 0;
  320. metadata.gid = 0;
  321. metadata.size = 0;
  322. metadata.mtime = mepoch;
  323. return metadata;
  324. }
  325. }