ProcessSpecificExposed.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288
  1. /*
  2. * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/JsonArraySerializer.h>
  7. #include <AK/JsonObjectSerializer.h>
  8. #include <AK/JsonValue.h>
  9. #include <Kernel/Arch/x86/InterruptDisabler.h>
  10. #include <Kernel/FileSystem/Custody.h>
  11. #include <Kernel/FileSystem/ProcFS.h>
  12. #include <Kernel/KBufferBuilder.h>
  13. #include <Kernel/Memory/AnonymousVMObject.h>
  14. #include <Kernel/Memory/MemoryManager.h>
  15. #include <Kernel/Process.h>
  16. #include <Kernel/ProcessExposed.h>
  17. namespace Kernel {
  18. KResultOr<size_t> Process::procfs_get_thread_stack(ThreadID thread_id, KBufferBuilder& builder) const
  19. {
  20. JsonArraySerializer array { builder };
  21. auto thread = Thread::from_tid(thread_id);
  22. if (!thread)
  23. return KResult(ESRCH);
  24. bool show_kernel_addresses = Process::current()->is_superuser();
  25. bool kernel_address_added = false;
  26. for (auto address : Processor::capture_stack_trace(*thread, 1024)) {
  27. if (!show_kernel_addresses && !Memory::is_user_address(VirtualAddress { address })) {
  28. if (kernel_address_added)
  29. continue;
  30. address = 0xdeadc0de;
  31. kernel_address_added = true;
  32. }
  33. array.add(address);
  34. }
  35. array.finish();
  36. return KSuccess;
  37. }
  38. KResult Process::traverse_stacks_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
  39. {
  40. callback({ ".", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property(pid(), SegmentedProcFSIndex::ProcessSubDirectory::Stacks, SegmentedProcFSIndex::MainProcessProperty::Reserved) }, 0 });
  41. callback({ "..", { fsid, m_procfs_traits->component_index() }, 0 });
  42. for_each_thread([&](const Thread& thread) {
  43. int tid = thread.tid().value();
  44. InodeIdentifier identifier = { fsid, SegmentedProcFSIndex::build_segmented_index_for_thread_stack(pid(), thread.tid()) };
  45. callback({ String::number(tid), identifier, 0 });
  46. });
  47. return KSuccess;
  48. }
  49. KResultOr<NonnullRefPtr<Inode>> Process::lookup_stacks_directory(const ProcFS& procfs, StringView name) const
  50. {
  51. KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> thread_stack_inode { ENOENT };
  52. // FIXME: Try to exit the loop earlier
  53. for_each_thread([&](const Thread& thread) {
  54. int tid = thread.tid().value();
  55. VERIFY(!(tid < 0));
  56. if (name.to_int() == tid) {
  57. auto maybe_inode = ProcFSProcessPropertyInode::try_create_for_thread_stack(procfs, thread.tid(), pid());
  58. if (maybe_inode.is_error()) {
  59. thread_stack_inode = maybe_inode.error();
  60. return;
  61. }
  62. thread_stack_inode = maybe_inode.release_value();
  63. }
  64. });
  65. if (thread_stack_inode.is_error())
  66. return thread_stack_inode.error();
  67. return thread_stack_inode.release_value();
  68. }
  69. KResultOr<size_t> Process::procfs_get_file_description_link(unsigned fd, KBufferBuilder& builder) const
  70. {
  71. auto file_description = m_fds.file_description(fd);
  72. if (!file_description)
  73. return EBADF;
  74. auto data = file_description->absolute_path();
  75. builder.append(data);
  76. return data.length();
  77. }
  78. KResult Process::traverse_file_descriptions_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
  79. {
  80. callback({ ".", { fsid, m_procfs_traits->component_index() }, 0 });
  81. callback({ "..", { fsid, m_procfs_traits->component_index() }, 0 });
  82. size_t count = 0;
  83. fds().enumerate([&](auto& file_description_metadata) {
  84. if (!file_description_metadata.is_valid()) {
  85. count++;
  86. return;
  87. }
  88. InodeIdentifier identifier = { fsid, SegmentedProcFSIndex::build_segmented_index_for_file_description(pid(), count) };
  89. callback({ String::number(count), identifier, 0 });
  90. count++;
  91. });
  92. return KSuccess;
  93. }
  94. KResultOr<NonnullRefPtr<Inode>> Process::lookup_file_descriptions_directory(const ProcFS& procfs, StringView name) const
  95. {
  96. KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> file_description_link { ENOENT };
  97. // FIXME: Try to exit the loop earlier
  98. size_t count = 0;
  99. fds().enumerate([&](auto& file_description_metadata) {
  100. if (!file_description_metadata.is_valid()) {
  101. count++;
  102. return;
  103. }
  104. if (name.to_uint() == count) {
  105. auto maybe_inode = ProcFSProcessPropertyInode::try_create_for_file_description_link(procfs, static_cast<unsigned>(count), pid());
  106. if (maybe_inode.is_error()) {
  107. file_description_link = maybe_inode.error();
  108. return;
  109. }
  110. file_description_link = maybe_inode.release_value();
  111. }
  112. count++;
  113. });
  114. if (file_description_link.is_error())
  115. return file_description_link.error();
  116. return file_description_link.release_value();
  117. }
  118. KResult Process::procfs_get_pledge_stats(KBufferBuilder& builder) const
  119. {
  120. JsonObjectSerializer obj { builder };
  121. #define __ENUMERATE_PLEDGE_PROMISE(x) \
  122. if (has_promised(Pledge::x)) { \
  123. if (!builder.is_empty()) \
  124. builder.append(' '); \
  125. builder.append(#x); \
  126. }
  127. if (has_promises()) {
  128. StringBuilder builder;
  129. ENUMERATE_PLEDGE_PROMISES
  130. obj.add("promises", builder.build());
  131. }
  132. #undef __ENUMERATE_PLEDGE_PROMISE
  133. obj.finish();
  134. return KSuccess;
  135. }
  136. KResult Process::procfs_get_unveil_stats(KBufferBuilder& builder) const
  137. {
  138. JsonArraySerializer array { builder };
  139. for (auto& unveiled_path : unveiled_paths()) {
  140. if (!unveiled_path.was_explicitly_unveiled())
  141. continue;
  142. auto obj = array.add_object();
  143. obj.add("path", unveiled_path.path());
  144. StringBuilder permissions_builder;
  145. if (unveiled_path.permissions() & UnveilAccess::Read)
  146. permissions_builder.append('r');
  147. if (unveiled_path.permissions() & UnveilAccess::Write)
  148. permissions_builder.append('w');
  149. if (unveiled_path.permissions() & UnveilAccess::Execute)
  150. permissions_builder.append('x');
  151. if (unveiled_path.permissions() & UnveilAccess::CreateOrRemove)
  152. permissions_builder.append('c');
  153. if (unveiled_path.permissions() & UnveilAccess::Browse)
  154. permissions_builder.append('b');
  155. obj.add("permissions", permissions_builder.to_string());
  156. }
  157. array.finish();
  158. return KSuccess;
  159. }
  160. KResult Process::procfs_get_perf_events(KBufferBuilder& builder) const
  161. {
  162. InterruptDisabler disabler;
  163. if (!const_cast<Process&>(*this).perf_events()) {
  164. dbgln("ProcFS: No perf events for {}", pid());
  165. return KResult(ENOBUFS);
  166. }
  167. return const_cast<Process&>(*this).perf_events()->to_json(builder) ? KSuccess : KResult(EINVAL);
  168. }
  169. KResult Process::procfs_get_fds_stats(KBufferBuilder& builder) const
  170. {
  171. JsonArraySerializer array { builder };
  172. if (fds().open_count() == 0) {
  173. array.finish();
  174. return KSuccess;
  175. }
  176. size_t count = 0;
  177. fds().enumerate([&](auto& file_description_metadata) {
  178. if (!file_description_metadata.is_valid()) {
  179. count++;
  180. return;
  181. }
  182. bool cloexec = file_description_metadata.flags() & FD_CLOEXEC;
  183. RefPtr<FileDescription> description = file_description_metadata.description();
  184. auto description_object = array.add_object();
  185. description_object.add("fd", count);
  186. description_object.add("absolute_path", description->absolute_path());
  187. description_object.add("seekable", description->file().is_seekable());
  188. description_object.add("class", description->file().class_name());
  189. description_object.add("offset", description->offset());
  190. description_object.add("cloexec", cloexec);
  191. description_object.add("blocking", description->is_blocking());
  192. description_object.add("can_read", description->can_read());
  193. description_object.add("can_write", description->can_write());
  194. count++;
  195. });
  196. array.finish();
  197. return KSuccess;
  198. }
  199. KResult Process::procfs_get_virtual_memory_stats(KBufferBuilder& builder) const
  200. {
  201. JsonArraySerializer array { builder };
  202. {
  203. ScopedSpinLock lock(address_space().get_lock());
  204. for (auto& region : address_space().regions()) {
  205. if (!region->is_user() && !Process::current()->is_superuser())
  206. continue;
  207. auto region_object = array.add_object();
  208. region_object.add("readable", region->is_readable());
  209. region_object.add("writable", region->is_writable());
  210. region_object.add("executable", region->is_executable());
  211. region_object.add("stack", region->is_stack());
  212. region_object.add("shared", region->is_shared());
  213. region_object.add("syscall", region->is_syscall_region());
  214. region_object.add("purgeable", region->vmobject().is_anonymous());
  215. if (region->vmobject().is_anonymous()) {
  216. region_object.add("volatile", static_cast<Memory::AnonymousVMObject const&>(region->vmobject()).is_volatile());
  217. }
  218. region_object.add("cacheable", region->is_cacheable());
  219. region_object.add("address", region->vaddr().get());
  220. region_object.add("size", region->size());
  221. region_object.add("amount_resident", region->amount_resident());
  222. region_object.add("amount_dirty", region->amount_dirty());
  223. region_object.add("cow_pages", region->cow_pages());
  224. region_object.add("name", region->name());
  225. region_object.add("vmobject", region->vmobject().class_name());
  226. StringBuilder pagemap_builder;
  227. for (size_t i = 0; i < region->page_count(); ++i) {
  228. auto* page = region->physical_page(i);
  229. if (!page)
  230. pagemap_builder.append('N');
  231. else if (page->is_shared_zero_page() || page->is_lazy_committed_page())
  232. pagemap_builder.append('Z');
  233. else
  234. pagemap_builder.append('P');
  235. }
  236. region_object.add("pagemap", pagemap_builder.to_string());
  237. }
  238. }
  239. array.finish();
  240. return KSuccess;
  241. }
  242. KResult Process::procfs_get_current_work_directory_link(KBufferBuilder& builder) const
  243. {
  244. builder.append_bytes(const_cast<Process&>(*this).current_directory().absolute_path().bytes());
  245. return KSuccess;
  246. }
  247. mode_t Process::binary_link_required_mode() const
  248. {
  249. if (!executable())
  250. return 0;
  251. return m_procfs_traits->required_mode();
  252. }
  253. KResult Process::procfs_get_binary_link(KBufferBuilder& builder) const
  254. {
  255. auto* custody = executable();
  256. if (!custody)
  257. return KResult(ENOEXEC);
  258. builder.append(custody->absolute_path().bytes());
  259. return KSuccess;
  260. }
  261. }