Inode.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372
  1. /*
  2. * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <AK/NonnullRefPtrVector.h>
  8. #include <AK/Singleton.h>
  9. #include <AK/StringView.h>
  10. #include <Kernel/API/InodeWatcherEvent.h>
  11. #include <Kernel/FileSystem/Custody.h>
  12. #include <Kernel/FileSystem/Inode.h>
  13. #include <Kernel/FileSystem/InodeWatcher.h>
  14. #include <Kernel/FileSystem/OpenFileDescription.h>
  15. #include <Kernel/FileSystem/VirtualFileSystem.h>
  16. #include <Kernel/KBufferBuilder.h>
  17. #include <Kernel/Memory/SharedInodeVMObject.h>
  18. #include <Kernel/Net/LocalSocket.h>
  19. #include <Kernel/Process.h>
  20. namespace Kernel {
  21. static Singleton<SpinlockProtected<Inode::AllInstancesList>> s_all_instances;
  22. SpinlockProtected<Inode::AllInstancesList>& Inode::all_instances()
  23. {
  24. return s_all_instances;
  25. }
  26. void Inode::sync_all()
  27. {
  28. NonnullRefPtrVector<Inode, 32> inodes;
  29. Inode::all_instances().with([&](auto& all_inodes) {
  30. for (auto& inode : all_inodes) {
  31. if (inode.is_metadata_dirty())
  32. inodes.append(inode);
  33. }
  34. });
  35. for (auto& inode : inodes) {
  36. VERIFY(inode.is_metadata_dirty());
  37. (void)inode.flush_metadata();
  38. }
  39. }
  40. void Inode::sync()
  41. {
  42. if (is_metadata_dirty())
  43. (void)flush_metadata();
  44. fs().flush_writes();
  45. }
  46. ErrorOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(OpenFileDescription* description) const
  47. {
  48. auto builder = TRY(KBufferBuilder::try_create());
  49. u8 buffer[4096];
  50. off_t offset = 0;
  51. for (;;) {
  52. auto buf = UserOrKernelBuffer::for_kernel_buffer(buffer);
  53. auto nread = TRY(read_bytes(offset, sizeof(buffer), buf, description));
  54. VERIFY(nread <= sizeof(buffer));
  55. if (nread == 0)
  56. break;
  57. TRY(builder.append((const char*)buffer, nread));
  58. offset += nread;
  59. if (nread < sizeof(buffer))
  60. break;
  61. }
  62. auto entire_file = builder.build();
  63. if (!entire_file)
  64. return ENOMEM;
  65. return entire_file.release_nonnull();
  66. }
  67. ErrorOr<NonnullRefPtr<Custody>> Inode::resolve_as_link(Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level) const
  68. {
  69. // The default implementation simply treats the stored
  70. // contents as a path and resolves that. That is, it
  71. // behaves exactly how you would expect a symlink to work.
  72. auto contents = TRY(read_entire());
  73. return VirtualFileSystem::the().resolve_path(StringView { contents->bytes() }, base, out_parent, options, symlink_recursion_level);
  74. }
  75. Inode::Inode(FileSystem& fs, InodeIndex index)
  76. : m_file_system(fs)
  77. , m_index(index)
  78. {
  79. Inode::all_instances().with([&](auto& all_inodes) { all_inodes.append(*this); });
  80. }
  81. Inode::~Inode()
  82. {
  83. for (auto& watcher : m_watchers) {
  84. watcher->unregister_by_inode({}, identifier());
  85. }
  86. }
  87. void Inode::will_be_destroyed()
  88. {
  89. MutexLocker locker(m_inode_lock);
  90. if (m_metadata_dirty)
  91. (void)flush_metadata();
  92. }
  93. ErrorOr<void> Inode::set_atime(time_t)
  94. {
  95. return ENOTIMPL;
  96. }
  97. ErrorOr<void> Inode::set_ctime(time_t)
  98. {
  99. return ENOTIMPL;
  100. }
  101. ErrorOr<void> Inode::set_mtime(time_t)
  102. {
  103. return ENOTIMPL;
  104. }
  105. ErrorOr<void> Inode::increment_link_count()
  106. {
  107. return ENOTIMPL;
  108. }
  109. ErrorOr<void> Inode::decrement_link_count()
  110. {
  111. return ENOTIMPL;
  112. }
  113. void Inode::set_shared_vmobject(Memory::SharedInodeVMObject& vmobject)
  114. {
  115. MutexLocker locker(m_inode_lock);
  116. m_shared_vmobject = vmobject;
  117. }
  118. bool Inode::bind_socket(LocalSocket& socket)
  119. {
  120. MutexLocker locker(m_inode_lock);
  121. if (m_socket)
  122. return false;
  123. m_socket = socket;
  124. return true;
  125. }
  126. bool Inode::unbind_socket()
  127. {
  128. MutexLocker locker(m_inode_lock);
  129. if (!m_socket)
  130. return false;
  131. m_socket = nullptr;
  132. return true;
  133. }
  134. void Inode::register_watcher(Badge<InodeWatcher>, InodeWatcher& watcher)
  135. {
  136. MutexLocker locker(m_inode_lock);
  137. VERIFY(!m_watchers.contains(&watcher));
  138. m_watchers.set(&watcher);
  139. }
  140. void Inode::unregister_watcher(Badge<InodeWatcher>, InodeWatcher& watcher)
  141. {
  142. MutexLocker locker(m_inode_lock);
  143. VERIFY(m_watchers.contains(&watcher));
  144. m_watchers.remove(&watcher);
  145. }
  146. ErrorOr<NonnullRefPtr<FIFO>> Inode::fifo()
  147. {
  148. MutexLocker locker(m_inode_lock);
  149. VERIFY(metadata().is_fifo());
  150. // FIXME: Release m_fifo when it is closed by all readers and writers
  151. if (!m_fifo)
  152. m_fifo = TRY(FIFO::try_create(metadata().uid));
  153. return NonnullRefPtr { *m_fifo };
  154. }
  155. void Inode::set_metadata_dirty(bool metadata_dirty)
  156. {
  157. MutexLocker locker(m_inode_lock);
  158. if (metadata_dirty) {
  159. // Sanity check.
  160. VERIFY(!fs().is_readonly());
  161. }
  162. if (m_metadata_dirty == metadata_dirty)
  163. return;
  164. m_metadata_dirty = metadata_dirty;
  165. if (m_metadata_dirty) {
  166. // FIXME: Maybe we should hook into modification events somewhere else, I'm not sure where.
  167. // We don't always end up on this particular code path, for instance when writing to an ext2fs file.
  168. for (auto& watcher : m_watchers) {
  169. watcher->notify_inode_event({}, identifier(), InodeWatcherEvent::Type::MetadataModified);
  170. }
  171. }
  172. }
  173. void Inode::did_add_child(InodeIdentifier, String const& name)
  174. {
  175. MutexLocker locker(m_inode_lock);
  176. for (auto& watcher : m_watchers) {
  177. watcher->notify_inode_event({}, identifier(), InodeWatcherEvent::Type::ChildCreated, name);
  178. }
  179. }
  180. void Inode::did_remove_child(InodeIdentifier, String const& name)
  181. {
  182. MutexLocker locker(m_inode_lock);
  183. if (name == "." || name == "..") {
  184. // These are just aliases and are not interesting to userspace.
  185. return;
  186. }
  187. for (auto& watcher : m_watchers) {
  188. watcher->notify_inode_event({}, identifier(), InodeWatcherEvent::Type::ChildDeleted, name);
  189. }
  190. }
  191. void Inode::did_modify_contents()
  192. {
  193. MutexLocker locker(m_inode_lock);
  194. for (auto& watcher : m_watchers) {
  195. watcher->notify_inode_event({}, identifier(), InodeWatcherEvent::Type::ContentModified);
  196. }
  197. }
  198. void Inode::did_delete_self()
  199. {
  200. MutexLocker locker(m_inode_lock);
  201. for (auto& watcher : m_watchers) {
  202. watcher->notify_inode_event({}, identifier(), InodeWatcherEvent::Type::Deleted);
  203. }
  204. }
  205. ErrorOr<void> Inode::prepare_to_write_data()
  206. {
  207. // FIXME: It's a poor design that filesystems are expected to call this before writing out data.
  208. // We should funnel everything through an interface at the VirtualFileSystem layer so this can happen from a single place.
  209. MutexLocker locker(m_inode_lock);
  210. if (fs().is_readonly())
  211. return EROFS;
  212. auto metadata = this->metadata();
  213. if (metadata.is_setuid() || metadata.is_setgid()) {
  214. dbgln("Inode::prepare_to_write_data(): Stripping SUID/SGID bits from {}", identifier());
  215. return chmod(metadata.mode & ~(04000 | 02000));
  216. }
  217. return {};
  218. }
  219. RefPtr<Memory::SharedInodeVMObject> Inode::shared_vmobject() const
  220. {
  221. MutexLocker locker(m_inode_lock);
  222. return m_shared_vmobject.strong_ref();
  223. }
  224. template<typename T>
  225. static inline bool range_overlap(T start1, T len1, T start2, T len2)
  226. {
  227. return ((start1 < start2 + len2) || len2 == 0) && ((start2 < start1 + len1) || len1 == 0);
  228. }
  229. static inline ErrorOr<void> normalize_flock(OpenFileDescription const& description, flock& lock)
  230. {
  231. off_t start;
  232. switch (lock.l_whence) {
  233. case SEEK_SET:
  234. start = lock.l_start;
  235. break;
  236. case SEEK_CUR:
  237. start = description.offset() + lock.l_start;
  238. break;
  239. case SEEK_END:
  240. // FIXME: Implement SEEK_END and negative lengths.
  241. return ENOTSUP;
  242. default:
  243. return EINVAL;
  244. }
  245. lock = { lock.l_type, SEEK_SET, start, lock.l_len, 0 };
  246. return {};
  247. }
  248. ErrorOr<void> Inode::can_apply_flock(OpenFileDescription const& description, flock const& new_lock) const
  249. {
  250. VERIFY(new_lock.l_whence == SEEK_SET);
  251. MutexLocker locker(m_inode_lock, Mutex::Mode::Shared);
  252. if (new_lock.l_type == F_UNLCK) {
  253. for (auto const& lock : m_flocks) {
  254. if (&description == lock.owner && lock.start == new_lock.l_start && lock.len == new_lock.l_len)
  255. return {};
  256. }
  257. return EINVAL;
  258. }
  259. for (auto const& lock : m_flocks) {
  260. if (!range_overlap(lock.start, lock.len, new_lock.l_start, new_lock.l_len))
  261. continue;
  262. if (new_lock.l_type == F_RDLCK && lock.type == F_WRLCK)
  263. return EAGAIN;
  264. if (new_lock.l_type == F_WRLCK)
  265. return EAGAIN;
  266. }
  267. return {};
  268. }
  269. ErrorOr<void> Inode::apply_flock(Process const& process, OpenFileDescription const& description, Userspace<flock const*> input_lock)
  270. {
  271. auto new_lock = TRY(copy_typed_from_user(input_lock));
  272. TRY(normalize_flock(description, new_lock));
  273. MutexLocker locker(m_inode_lock);
  274. TRY(can_apply_flock(description, new_lock));
  275. if (new_lock.l_type == F_UNLCK) {
  276. for (size_t i = 0; i < m_flocks.size(); ++i) {
  277. if (&description == m_flocks[i].owner && m_flocks[i].start == new_lock.l_start && m_flocks[i].len == new_lock.l_len) {
  278. m_flocks.remove(i);
  279. return {};
  280. }
  281. }
  282. return EINVAL;
  283. }
  284. TRY(m_flocks.try_append(Flock { new_lock.l_start, new_lock.l_len, &description, process.pid().value(), new_lock.l_type }));
  285. return {};
  286. }
  287. ErrorOr<void> Inode::get_flock(OpenFileDescription const& description, Userspace<flock*> reference_lock) const
  288. {
  289. flock lookup = {};
  290. TRY(copy_from_user(&lookup, reference_lock));
  291. TRY(normalize_flock(description, lookup));
  292. MutexLocker locker(m_inode_lock, Mutex::Mode::Shared);
  293. for (auto const& lock : m_flocks) {
  294. if (!range_overlap(lock.start, lock.len, lookup.l_start, lookup.l_len))
  295. continue;
  296. if ((lookup.l_type == F_RDLCK && lock.type == F_WRLCK) || lookup.l_type == F_WRLCK) {
  297. lookup = { lock.type, SEEK_SET, lock.start, lock.len, lock.pid };
  298. return copy_to_user(reference_lock, &lookup);
  299. }
  300. }
  301. lookup.l_type = F_UNLCK;
  302. return copy_to_user(reference_lock, &lookup);
  303. }
  304. void Inode::remove_flocks_for_description(OpenFileDescription const& description)
  305. {
  306. MutexLocker locker(m_inode_lock);
  307. for (size_t i = 0; i < m_flocks.size(); ++i) {
  308. if (&description == m_flocks[i].owner)
  309. m_flocks.remove(i--);
  310. }
  311. }
  312. }