ProcFS.cpp 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610
  1. /*
  2. * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
  4. * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/Singleton.h>
  9. #include <Kernel/API/POSIX/errno.h>
  10. #include <Kernel/Debug.h>
  11. #include <Kernel/FileSystem/Custody.h>
  12. #include <Kernel/FileSystem/OpenFileDescription.h>
  13. #include <Kernel/FileSystem/ProcFS.h>
  14. #include <Kernel/FileSystem/VirtualFileSystem.h>
  15. #include <Kernel/Heap/kmalloc.h>
  16. #include <Kernel/Process.h>
  17. #include <Kernel/Sections.h>
  18. namespace Kernel {
  19. static Singleton<ProcFSComponentRegistry> s_the;
  20. ProcFSComponentRegistry& ProcFSComponentRegistry::the()
  21. {
  22. return *s_the;
  23. }
  24. UNMAP_AFTER_INIT void ProcFSComponentRegistry::initialize()
  25. {
  26. VERIFY(!s_the.is_initialized());
  27. s_the.ensure_instance();
  28. }
  29. UNMAP_AFTER_INIT ProcFSComponentRegistry::ProcFSComponentRegistry()
  30. : m_root_directory(ProcFSRootDirectory::must_create())
  31. {
  32. }
  33. ErrorOr<NonnullLockRefPtr<FileSystem>> ProcFS::try_create()
  34. {
  35. return TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFS));
  36. }
  37. ProcFS::ProcFS() = default;
  38. ProcFS::~ProcFS() = default;
  39. ErrorOr<void> ProcFS::initialize()
  40. {
  41. m_root_inode = static_ptr_cast<ProcFSDirectoryInode>(TRY(ProcFSComponentRegistry::the().root_directory().to_inode(*this)));
  42. return {};
  43. }
  44. Inode& ProcFS::root_inode()
  45. {
  46. return *m_root_inode;
  47. }
  48. ProcFSInode::ProcFSInode(ProcFS const& fs, InodeIndex index)
  49. : Inode(const_cast<ProcFS&>(fs), index)
  50. {
  51. }
  52. ProcFSInode::~ProcFSInode() = default;
  53. ErrorOr<void> ProcFSInode::flush_metadata()
  54. {
  55. return {};
  56. }
  57. ErrorOr<void> ProcFSInode::add_child(Inode&, StringView, mode_t)
  58. {
  59. return EROFS;
  60. }
  61. ErrorOr<NonnullLockRefPtr<Inode>> ProcFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
  62. {
  63. return EROFS;
  64. }
  65. ErrorOr<void> ProcFSInode::remove_child(StringView)
  66. {
  67. return EROFS;
  68. }
  69. ErrorOr<void> ProcFSInode::chmod(mode_t)
  70. {
  71. return EPERM;
  72. }
  73. ErrorOr<void> ProcFSInode::chown(UserID, GroupID)
  74. {
  75. return EPERM;
  76. }
  77. ErrorOr<NonnullLockRefPtr<ProcFSGlobalInode>> ProcFSGlobalInode::try_create(ProcFS const& fs, ProcFSExposedComponent const& component)
  78. {
  79. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSGlobalInode(fs, component));
  80. }
  81. ProcFSGlobalInode::ProcFSGlobalInode(ProcFS const& fs, ProcFSExposedComponent const& component)
  82. : ProcFSInode(fs, component.component_index())
  83. , m_associated_component(component)
  84. {
  85. }
  86. void ProcFSGlobalInode::did_seek(OpenFileDescription& description, off_t new_offset)
  87. {
  88. if (new_offset != 0)
  89. return;
  90. auto result = m_associated_component->refresh_data(description);
  91. if (result.is_error()) {
  92. // Subsequent calls to read will return EIO!
  93. dbgln("ProcFS: Could not refresh contents: {}", result.error());
  94. }
  95. }
  96. ErrorOr<void> ProcFSGlobalInode::attach(OpenFileDescription& description)
  97. {
  98. return m_associated_component->refresh_data(description);
  99. }
  100. ErrorOr<size_t> ProcFSGlobalInode::read_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
  101. {
  102. return m_associated_component->read_bytes(offset, count, buffer, fd);
  103. }
  104. StringView ProcFSGlobalInode::name() const
  105. {
  106. return m_associated_component->name();
  107. }
  108. ErrorOr<void> ProcFSGlobalInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const
  109. {
  110. VERIFY_NOT_REACHED();
  111. }
  112. ErrorOr<NonnullLockRefPtr<Inode>> ProcFSGlobalInode::lookup(StringView)
  113. {
  114. VERIFY_NOT_REACHED();
  115. }
  116. ErrorOr<void> ProcFSGlobalInode::truncate(u64 size)
  117. {
  118. return m_associated_component->truncate(size);
  119. }
  120. ErrorOr<void> ProcFSGlobalInode::update_timestamps(Optional<time_t>, Optional<time_t>, Optional<time_t>)
  121. {
  122. return {};
  123. }
  124. InodeMetadata ProcFSGlobalInode::metadata() const
  125. {
  126. MutexLocker locker(m_inode_lock);
  127. InodeMetadata metadata;
  128. metadata.inode = { fsid(), m_associated_component->component_index() };
  129. metadata.mode = S_IFREG | m_associated_component->required_mode();
  130. metadata.uid = m_associated_component->owner_user();
  131. metadata.gid = m_associated_component->owner_group();
  132. metadata.size = 0;
  133. metadata.mtime = m_associated_component->modified_time();
  134. return metadata;
  135. }
  136. ErrorOr<size_t> ProcFSGlobalInode::write_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* fd)
  137. {
  138. return m_associated_component->write_bytes(offset, count, buffer, fd);
  139. }
  140. ErrorOr<NonnullLockRefPtr<ProcFSDirectoryInode>> ProcFSDirectoryInode::try_create(ProcFS const& procfs, ProcFSExposedComponent const& component)
  141. {
  142. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSDirectoryInode(procfs, component));
  143. }
  144. ProcFSDirectoryInode::ProcFSDirectoryInode(ProcFS const& fs, ProcFSExposedComponent const& component)
  145. : ProcFSGlobalInode(fs, component)
  146. {
  147. }
  148. ProcFSDirectoryInode::~ProcFSDirectoryInode() = default;
  149. InodeMetadata ProcFSDirectoryInode::metadata() const
  150. {
  151. MutexLocker locker(m_inode_lock);
  152. InodeMetadata metadata;
  153. metadata.inode = { fsid(), m_associated_component->component_index() };
  154. metadata.mode = S_IFDIR | m_associated_component->required_mode();
  155. metadata.uid = m_associated_component->owner_user();
  156. metadata.gid = m_associated_component->owner_group();
  157. metadata.size = 0;
  158. metadata.mtime = m_associated_component->modified_time();
  159. return metadata;
  160. }
  161. ErrorOr<void> ProcFSDirectoryInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
  162. {
  163. MutexLocker locker(procfs().m_lock);
  164. return m_associated_component->traverse_as_directory(procfs().fsid(), move(callback));
  165. }
  166. ErrorOr<NonnullLockRefPtr<Inode>> ProcFSDirectoryInode::lookup(StringView name)
  167. {
  168. MutexLocker locker(procfs().m_lock);
  169. auto component = TRY(m_associated_component->lookup(name));
  170. return component->to_inode(procfs());
  171. }
  172. ErrorOr<NonnullLockRefPtr<ProcFSLinkInode>> ProcFSLinkInode::try_create(ProcFS const& procfs, ProcFSExposedComponent const& component)
  173. {
  174. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSLinkInode(procfs, component));
  175. }
  176. ProcFSLinkInode::ProcFSLinkInode(ProcFS const& fs, ProcFSExposedComponent const& component)
  177. : ProcFSGlobalInode(fs, component)
  178. {
  179. }
  180. InodeMetadata ProcFSLinkInode::metadata() const
  181. {
  182. MutexLocker locker(m_inode_lock);
  183. InodeMetadata metadata;
  184. metadata.inode = { fsid(), m_associated_component->component_index() };
  185. metadata.mode = S_IFLNK | m_associated_component->required_mode();
  186. metadata.uid = m_associated_component->owner_user();
  187. metadata.gid = m_associated_component->owner_group();
  188. metadata.size = 0;
  189. metadata.mtime = m_associated_component->modified_time();
  190. return metadata;
  191. }
  192. ProcFSProcessAssociatedInode::ProcFSProcessAssociatedInode(ProcFS const& fs, ProcessID associated_pid, InodeIndex determined_index)
  193. : ProcFSInode(fs, determined_index)
  194. , m_pid(associated_pid)
  195. {
  196. }
  197. ErrorOr<size_t> ProcFSProcessAssociatedInode::write_bytes_locked(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
  198. {
  199. return ENOTSUP;
  200. }
  201. ErrorOr<NonnullLockRefPtr<ProcFSProcessDirectoryInode>> ProcFSProcessDirectoryInode::try_create(ProcFS const& procfs, ProcessID pid)
  202. {
  203. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessDirectoryInode(procfs, pid));
  204. }
  205. ProcFSProcessDirectoryInode::ProcFSProcessDirectoryInode(ProcFS const& procfs, ProcessID pid)
  206. : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_pid_directory(pid))
  207. {
  208. }
  209. ErrorOr<void> ProcFSProcessDirectoryInode::attach(OpenFileDescription&)
  210. {
  211. return {};
  212. }
  213. InodeMetadata ProcFSProcessDirectoryInode::metadata() const
  214. {
  215. MutexLocker locker(m_inode_lock);
  216. auto process = Process::from_pid(associated_pid());
  217. if (!process)
  218. return {};
  219. auto traits = process->procfs_traits();
  220. InodeMetadata metadata;
  221. metadata.inode = { fsid(), traits->component_index() };
  222. metadata.mode = S_IFDIR | traits->required_mode();
  223. metadata.uid = traits->owner_user();
  224. metadata.gid = traits->owner_group();
  225. metadata.size = 0;
  226. metadata.mtime = traits->modified_time();
  227. return metadata;
  228. }
  229. ErrorOr<size_t> ProcFSProcessDirectoryInode::read_bytes_locked(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
  230. {
  231. VERIFY_NOT_REACHED();
  232. }
  233. ErrorOr<void> ProcFSProcessDirectoryInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
  234. {
  235. MutexLocker locker(procfs().m_lock);
  236. auto process = Process::from_pid(associated_pid());
  237. if (!process)
  238. return EINVAL;
  239. return process->procfs_traits()->traverse_as_directory(procfs().fsid(), move(callback));
  240. }
  241. ErrorOr<NonnullLockRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView name)
  242. {
  243. MutexLocker locker(procfs().m_lock);
  244. auto process = Process::from_pid(associated_pid());
  245. if (!process)
  246. return ESRCH;
  247. if (name == "fd"sv)
  248. return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions, associated_pid()));
  249. if (name == "stacks"sv)
  250. return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::Stacks, associated_pid()));
  251. if (name == "children"sv)
  252. return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::Children, associated_pid()));
  253. if (name == "unveil"sv)
  254. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::Unveil, associated_pid()));
  255. if (name == "pledge"sv)
  256. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::Pledge, associated_pid()));
  257. if (name == "fds"sv)
  258. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions, associated_pid()));
  259. if (name == "exe"sv)
  260. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::BinaryLink, associated_pid()));
  261. if (name == "cwd"sv)
  262. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink, associated_pid()));
  263. if (name == "perf_events"sv)
  264. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents, associated_pid()));
  265. if (name == "vm"sv)
  266. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::VirtualMemoryStats, associated_pid()));
  267. if (name == "cmdline"sv)
  268. return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::CommandLine, associated_pid()));
  269. return ENOENT;
  270. }
  271. ErrorOr<NonnullLockRefPtr<ProcFSProcessSubDirectoryInode>> ProcFSProcessSubDirectoryInode::try_create(ProcFS const& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
  272. {
  273. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessSubDirectoryInode(procfs, sub_directory_type, pid));
  274. }
  275. ProcFSProcessSubDirectoryInode::ProcFSProcessSubDirectoryInode(ProcFS const& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
  276. : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_sub_directory(pid, sub_directory_type))
  277. , m_sub_directory_type(sub_directory_type)
  278. {
  279. }
  280. ErrorOr<size_t> ProcFSProcessSubDirectoryInode::read_bytes_locked(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
  281. {
  282. VERIFY_NOT_REACHED();
  283. }
  284. ErrorOr<void> ProcFSProcessSubDirectoryInode::attach(OpenFileDescription&)
  285. {
  286. return {};
  287. }
  288. void ProcFSProcessSubDirectoryInode::did_seek(OpenFileDescription&, off_t)
  289. {
  290. VERIFY_NOT_REACHED();
  291. }
  292. InodeMetadata ProcFSProcessSubDirectoryInode::metadata() const
  293. {
  294. MutexLocker locker(m_inode_lock);
  295. auto process = Process::from_pid(associated_pid());
  296. if (!process)
  297. return {};
  298. auto traits = process->procfs_traits();
  299. InodeMetadata metadata;
  300. metadata.inode = { fsid(), traits->component_index() };
  301. metadata.mode = S_IFDIR | traits->required_mode();
  302. metadata.uid = traits->owner_user();
  303. metadata.gid = traits->owner_group();
  304. metadata.size = 0;
  305. metadata.mtime = traits->modified_time();
  306. return metadata;
  307. }
  308. ErrorOr<void> ProcFSProcessSubDirectoryInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
  309. {
  310. MutexLocker locker(procfs().m_lock);
  311. auto process = Process::from_pid(associated_pid());
  312. if (!process)
  313. return EINVAL;
  314. switch (m_sub_directory_type) {
  315. case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
  316. return process->traverse_file_descriptions_directory(procfs().fsid(), move(callback));
  317. case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
  318. return process->traverse_stacks_directory(procfs().fsid(), move(callback));
  319. case SegmentedProcFSIndex::ProcessSubDirectory::Children:
  320. return process->traverse_children_directory(procfs().fsid(), move(callback));
  321. default:
  322. VERIFY_NOT_REACHED();
  323. }
  324. VERIFY_NOT_REACHED();
  325. }
  326. ErrorOr<NonnullLockRefPtr<Inode>> ProcFSProcessSubDirectoryInode::lookup(StringView name)
  327. {
  328. MutexLocker locker(procfs().m_lock);
  329. auto process = Process::from_pid(associated_pid());
  330. if (!process)
  331. return ESRCH;
  332. switch (m_sub_directory_type) {
  333. case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
  334. return process->lookup_file_descriptions_directory(procfs(), name);
  335. case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
  336. return process->lookup_stacks_directory(procfs(), name);
  337. case SegmentedProcFSIndex::ProcessSubDirectory::Children:
  338. return process->lookup_children_directory(procfs(), name);
  339. default:
  340. VERIFY_NOT_REACHED();
  341. }
  342. }
  343. ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_file_description_link(ProcFS const& procfs, unsigned file_description_index, ProcessID pid)
  344. {
  345. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, file_description_index, pid));
  346. }
  347. ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_thread_stack(ProcFS const& procfs, ThreadID stack_thread_index, ProcessID pid)
  348. {
  349. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, stack_thread_index, pid));
  350. }
  351. ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_pid_property(ProcFS const& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
  352. {
  353. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, main_property_type, pid));
  354. }
  355. ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_child_process_link(ProcFS const& procfs, ProcessID child_pid, ProcessID pid)
  356. {
  357. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, child_pid, pid));
  358. }
  359. ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
  360. : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(pid, main_property_type))
  361. , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Reserved)
  362. {
  363. m_possible_data.property_type = main_property_type;
  364. }
  365. ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, unsigned file_description_index, ProcessID pid)
  366. : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_file_description(pid, file_description_index))
  367. , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
  368. {
  369. m_possible_data.property_index = file_description_index;
  370. }
  371. ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, ThreadID thread_stack_index, ProcessID pid)
  372. : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_thread_stack(pid, thread_stack_index))
  373. , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
  374. {
  375. m_possible_data.property_index = thread_stack_index.value();
  376. }
  377. ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, ProcessID child_pid, ProcessID pid)
  378. : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_children(pid, child_pid))
  379. , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Children)
  380. {
  381. m_possible_data.property_index = child_pid.value();
  382. }
  383. ErrorOr<void> ProcFSProcessPropertyInode::attach(OpenFileDescription& description)
  384. {
  385. return refresh_data(description);
  386. }
  387. void ProcFSProcessPropertyInode::did_seek(OpenFileDescription& description, off_t offset)
  388. {
  389. if (offset != 0)
  390. return;
  391. (void)refresh_data(description);
  392. }
  393. static mode_t determine_procfs_process_inode_mode(SegmentedProcFSIndex::ProcessSubDirectory parent_sub_directory_type, SegmentedProcFSIndex::MainProcessProperty main_property)
  394. {
  395. if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
  396. return S_IFLNK | 0400;
  397. if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
  398. return S_IFREG | 0400;
  399. if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Children)
  400. return S_IFLNK | 0400;
  401. VERIFY(parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Reserved);
  402. if (main_property == SegmentedProcFSIndex::MainProcessProperty::BinaryLink)
  403. return S_IFLNK | 0777;
  404. if (main_property == SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink)
  405. return S_IFLNK | 0777;
  406. return S_IFREG | 0400;
  407. }
  408. InodeMetadata ProcFSProcessPropertyInode::metadata() const
  409. {
  410. MutexLocker locker(m_inode_lock);
  411. auto process = Process::from_pid(associated_pid());
  412. if (!process)
  413. return {};
  414. auto traits = process->procfs_traits();
  415. InodeMetadata metadata;
  416. metadata.inode = { fsid(), traits->component_index() };
  417. metadata.mode = determine_procfs_process_inode_mode(m_parent_sub_directory_type, m_possible_data.property_type);
  418. metadata.uid = traits->owner_user();
  419. metadata.gid = traits->owner_group();
  420. metadata.size = 0;
  421. metadata.mtime = traits->modified_time();
  422. return metadata;
  423. }
  424. ErrorOr<void> ProcFSProcessPropertyInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const
  425. {
  426. VERIFY_NOT_REACHED();
  427. }
  428. ErrorOr<size_t> ProcFSProcessPropertyInode::read_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
  429. {
  430. dbgln_if(PROCFS_DEBUG, "ProcFS ProcessInformation: read_bytes_locked offset: {} count: {}", offset, count);
  431. VERIFY(offset >= 0);
  432. VERIFY(buffer.user_or_kernel_ptr());
  433. if (!description) {
  434. auto builder = TRY(KBufferBuilder::try_create());
  435. auto process = Process::from_pid(associated_pid());
  436. if (!process)
  437. return Error::from_errno(ESRCH);
  438. TRY(try_to_acquire_data(*process, builder));
  439. auto data_buffer = builder.build();
  440. if (!data_buffer)
  441. return Error::from_errno(EFAULT);
  442. ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
  443. TRY(buffer.write(data_buffer->data() + offset, nread));
  444. return nread;
  445. }
  446. if (!description->data()) {
  447. dbgln("ProcFS Process Information: Do not have cached data!");
  448. return Error::from_errno(EIO);
  449. }
  450. MutexLocker locker(m_refresh_lock);
  451. auto& typed_cached_data = static_cast<ProcFSInodeData&>(*description->data());
  452. auto& data_buffer = typed_cached_data.buffer;
  453. if (!data_buffer || (size_t)offset >= data_buffer->size())
  454. return 0;
  455. ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
  456. TRY(buffer.write(data_buffer->data() + offset, nread));
  457. return nread;
  458. }
  459. ErrorOr<NonnullLockRefPtr<Inode>> ProcFSProcessPropertyInode::lookup(StringView)
  460. {
  461. return EINVAL;
  462. }
  463. static ErrorOr<void> build_from_cached_data(KBufferBuilder& builder, ProcFSInodeData& cached_data)
  464. {
  465. cached_data.buffer = builder.build();
  466. if (!cached_data.buffer)
  467. return ENOMEM;
  468. return {};
  469. }
  470. ErrorOr<void> ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBufferBuilder& builder) const
  471. {
  472. // FIXME: Verify process is already ref-counted
  473. if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions) {
  474. TRY(process.procfs_get_file_description_link(m_possible_data.property_index, builder));
  475. return {};
  476. }
  477. if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks) {
  478. TRY(process.procfs_get_thread_stack(m_possible_data.property_index, builder));
  479. return {};
  480. }
  481. if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Children) {
  482. TRY(process.procfs_get_child_proccess_link(m_possible_data.property_index, builder));
  483. return {};
  484. }
  485. VERIFY(m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Reserved);
  486. switch (m_possible_data.property_type) {
  487. case SegmentedProcFSIndex::MainProcessProperty::Unveil:
  488. return process.procfs_get_unveil_stats(builder);
  489. case SegmentedProcFSIndex::MainProcessProperty::Pledge:
  490. return process.procfs_get_pledge_stats(builder);
  491. case SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions:
  492. return process.procfs_get_fds_stats(builder);
  493. case SegmentedProcFSIndex::MainProcessProperty::BinaryLink:
  494. return process.procfs_get_binary_link(builder);
  495. case SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink:
  496. return process.procfs_get_current_work_directory_link(builder);
  497. case SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents:
  498. return process.procfs_get_perf_events(builder);
  499. case SegmentedProcFSIndex::MainProcessProperty::VirtualMemoryStats:
  500. return process.procfs_get_virtual_memory_stats(builder);
  501. case SegmentedProcFSIndex::MainProcessProperty::CommandLine:
  502. return process.procfs_get_command_line(builder);
  503. default:
  504. VERIFY_NOT_REACHED();
  505. }
  506. }
  507. ErrorOr<void> ProcFSProcessPropertyInode::refresh_data(OpenFileDescription& description)
  508. {
  509. // For process-specific inodes, hold the process's ptrace lock across refresh
  510. // and refuse to load data if the process is not dumpable.
  511. // Without this, files opened before a process went non-dumpable could still be used for dumping.
  512. auto process = Process::from_pid(associated_pid());
  513. if (!process)
  514. return Error::from_errno(ESRCH);
  515. process->ptrace_lock().lock();
  516. if (!process->is_dumpable()) {
  517. process->ptrace_lock().unlock();
  518. return EPERM;
  519. }
  520. ScopeGuard guard = [&] {
  521. process->ptrace_lock().unlock();
  522. };
  523. MutexLocker locker(m_refresh_lock);
  524. auto& cached_data = description.data();
  525. if (!cached_data) {
  526. cached_data = adopt_own_if_nonnull(new (nothrow) ProcFSInodeData);
  527. if (!cached_data)
  528. return ENOMEM;
  529. }
  530. auto builder = TRY(KBufferBuilder::try_create());
  531. TRY(try_to_acquire_data(*process, builder));
  532. return build_from_cached_data(builder, static_cast<ProcFSInodeData&>(*cached_data));
  533. }
  534. }