Kernel/ProcFS: Split code into more separate files

Instead of using one file for the entire "backend" of the ProcFS data
and metadata, we could split that file into two files that represent
2 logical chunks of the ProcFS exposed objects:
1. Global and inter-process information. This includes all fixed data in
the root folder of the ProcFS, networking information and the bus
folder.
2. Per-process information. This includes all dynamic data about a
process that resides in the /proc/PID/ folder.

This change makes it more easier to read the code and to change it,
hence we do it although there's no technical benefit from it now :)

1 files changed, 492 insertions, 0 deletions

diff --git a/Kernel/ProcessSpecificExposed.cpp b/Kernel/ProcessSpecificExposed.cpp
new file mode 100644
index 0000000000..45b244649c
--- /dev/null
+++ b/Kernel/ProcessSpecificExposed.cpp
@@ -0,0 +1,492 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/JsonArraySerializer.h>
+#include <AK/JsonObject.h>
+#include <AK/JsonObjectSerializer.h>
+#include <AK/JsonValue.h>
+#include <Kernel/Arch/x86/InterruptDisabler.h>
+#include <Kernel/FileSystem/Custody.h>
+#include <Kernel/KBufferBuilder.h>
+#include <Kernel/ProcessExposed.h>
+#include <Kernel/VM/AnonymousVMObject.h>
+#include <Kernel/VM/MemoryManager.h>
+
+namespace Kernel {
+
+class ProcFSProcessStacks;
+class ProcFSThreadStack final : public ProcFSProcessInformation {
+public:
+    // Note: We pass const ProcFSProcessStacks& to enforce creation with this type of folder
+    static NonnullRefPtr<ProcFSThreadStack> create(const ProcFSProcessFolder& process_folder, const ProcFSProcessStacks&, const Thread& thread)
+    {
+        return adopt_ref(*new (nothrow) ProcFSThreadStack(process_folder, thread));
+    }
+
+private:
+    explicit ProcFSThreadStack(const ProcFSProcessFolder& process_folder, const Thread& thread)
+        : ProcFSProcessInformation(String::formatted("{}", thread.tid()), process_folder)
+        , m_associated_thread(thread)
+    {
+    }
+    virtual bool output(KBufferBuilder& builder) override
+    {
+        JsonArraySerializer array { builder };
+        bool show_kernel_addresses = Process::current()->is_superuser();
+        bool kernel_address_added = false;
+        for (auto address : Processor::capture_stack_trace(*m_associated_thread, 1024)) {
+            if (!show_kernel_addresses && !is_user_address(VirtualAddress { address })) {
+                if (kernel_address_added)
+                    continue;
+                address = 0xdeadc0de;
+                kernel_address_added = true;
+            }
+            array.add(JsonValue(address));
+        }
+
+        array.finish();
+        return true;
+    }
+
+    NonnullRefPtr<Thread> m_associated_thread;
+};
+
+class ProcFSProcessStacks final : public ProcFSExposedFolder {
+    // Note: This folder is special, because everything that is created here is dynamic!
+    // This means we don't register anything in the m_components Vector, and every inode
+    // is created in runtime when called to get it
+    // Every ProcFSThreadStack (that represents a thread stack) is created only as a temporary object
+    // therefore, we don't use m_components so when we are done with the ProcFSThreadStack object,
+    // It should be deleted (as soon as possible)
+public:
+    virtual KResultOr<size_t> entries_count() const override;
+    virtual KResult traverse_as_directory(unsigned, Function<bool(const FS::DirectoryEntryView&)>) const override;
+    virtual RefPtr<ProcFSExposedComponent> lookup(StringView name) override;
+
+    static NonnullRefPtr<ProcFSProcessStacks> create(const ProcFSProcessFolder& parent_folder)
+    {
+        auto folder = adopt_ref(*new (nothrow) ProcFSProcessStacks(parent_folder));
+        return folder;
+    }
+
+    virtual void prepare_for_deletion() override
+    {
+        ProcFSExposedFolder::prepare_for_deletion();
+        m_process_folder.clear();
+    }
+
+private:
+    ProcFSProcessStacks(const ProcFSProcessFolder& parent_folder)
+        : ProcFSExposedFolder("stacks"sv, parent_folder)
+        , m_process_folder(parent_folder)
+    {
+    }
+    RefPtr<ProcFSProcessFolder> m_process_folder;
+    mutable Lock m_lock;
+};
+
+KResultOr<size_t> ProcFSProcessStacks::entries_count() const
+{
+    Locker locker(m_lock);
+    auto process = m_process_folder->m_associated_process;
+    return process->thread_count();
+}
+
+KResult ProcFSProcessStacks::traverse_as_directory(unsigned fsid, Function<bool(const FS::DirectoryEntryView&)> callback) const
+{
+    Locker locker(m_lock);
+    callback({ ".", { fsid, component_index() }, 0 });
+    callback({ "..", { fsid, m_parent_folder->component_index() }, 0 });
+
+    auto process = m_process_folder->m_associated_process;
+    process->for_each_thread([&](const Thread& thread) {
+        int tid = thread.tid().value();
+        InodeIdentifier identifier = { fsid, thread.global_procfs_inode_index() };
+        callback({ String::number(tid), identifier, 0 });
+    });
+    return KSuccess;
+}
+
+RefPtr<ProcFSExposedComponent> ProcFSProcessStacks::lookup(StringView name)
+{
+    Locker locker(m_lock);
+    auto process = m_process_folder->m_associated_process;
+    RefPtr<ProcFSThreadStack> procfd_stack;
+    // FIXME: Try to exit the loop earlier
+    process->for_each_thread([&](const Thread& thread) {
+        int tid = thread.tid().value();
+        if (name == String::number(tid)) {
+            procfd_stack = ProcFSThreadStack::create(*m_process_folder, *this, thread);
+        }
+    });
+    return procfd_stack;
+}
+
+class ProcFSProcessFileDescriptions;
+class ProcFSProcessFileDescription final : public ProcFSExposedLink {
+public:
+    // Note: we pass const ProcFSProcessFileDescriptions& just to enforce creation of this in the correct folder.
+    static NonnullRefPtr<ProcFSProcessFileDescription> create(unsigned fd_number, const FileDescription& fd, InodeIndex preallocated_index, const ProcFSProcessFileDescriptions&)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessFileDescription(fd_number, fd, preallocated_index));
+    }
+
+private:
+    explicit ProcFSProcessFileDescription(unsigned fd_number, const FileDescription& fd, InodeIndex preallocated_index)
+        : ProcFSExposedLink(String::formatted("{}", fd_number), preallocated_index)
+        , m_associated_file_description(fd)
+    {
+    }
+    virtual bool acquire_link(KBufferBuilder& builder) override
+    {
+        builder.append_bytes(m_associated_file_description->absolute_path().bytes());
+        return true;
+    }
+
+    NonnullRefPtr<FileDescription> m_associated_file_description;
+};
+
+class ProcFSProcessFileDescriptions final : public ProcFSExposedFolder {
+    // Note: This folder is special, because everything that is created here is dynamic!
+    // This means we don't register anything in the m_components Vector, and every inode
+    // is created in runtime when called to get it
+    // Every ProcFSProcessFileDescription (that represents a file descriptor) is created only as a temporary object
+    // therefore, we don't use m_components so when we are done with the ProcFSProcessFileDescription object,
+    // It should be deleted (as soon as possible)
+public:
+    virtual KResultOr<size_t> entries_count() const override;
+    virtual KResult traverse_as_directory(unsigned, Function<bool(const FS::DirectoryEntryView&)>) const override;
+    virtual RefPtr<ProcFSExposedComponent> lookup(StringView name) override;
+
+    static NonnullRefPtr<ProcFSProcessFileDescriptions> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessFileDescriptions(parent_folder));
+    }
+
+    virtual void prepare_for_deletion() override
+    {
+        ProcFSExposedFolder::prepare_for_deletion();
+        m_process_folder.clear();
+    }
+
+private:
+    explicit ProcFSProcessFileDescriptions(const ProcFSProcessFolder& parent_folder)
+        : ProcFSExposedFolder("fd"sv, parent_folder)
+        , m_process_folder(parent_folder)
+    {
+    }
+    RefPtr<ProcFSProcessFolder> m_process_folder;
+    mutable Lock m_lock;
+};
+
+KResultOr<size_t> ProcFSProcessFileDescriptions::entries_count() const
+{
+    Locker locker(m_lock);
+    return m_process_folder->m_associated_process->fds().open_count();
+}
+KResult ProcFSProcessFileDescriptions::traverse_as_directory(unsigned fsid, Function<bool(const FS::DirectoryEntryView&)> callback) const
+{
+    Locker locker(m_lock);
+    callback({ ".", { fsid, component_index() }, 0 });
+    callback({ "..", { fsid, m_parent_folder->component_index() }, 0 });
+
+    auto process = m_process_folder->m_associated_process;
+    size_t count = 0;
+    m_process_folder->m_associated_process->fds().enumerate([&](auto& file_description_metadata) {
+        if (!file_description_metadata.is_valid()) {
+            count++;
+            return;
+        }
+        InodeIdentifier identifier = { fsid, file_description_metadata.global_procfs_inode_index() };
+        callback({ String::number(count), identifier, 0 });
+        count++;
+    });
+    return KSuccess;
+}
+RefPtr<ProcFSExposedComponent> ProcFSProcessFileDescriptions::lookup(StringView name)
+{
+    Locker locker(m_lock);
+    auto process = m_process_folder->m_associated_process;
+    RefPtr<ProcFSProcessFileDescription> procfd_fd;
+    // FIXME: Try to exit the loop earlier
+    size_t count = 0;
+    m_process_folder->m_associated_process->fds().enumerate([&](auto& file_description_metadata) {
+        if (!file_description_metadata.is_valid()) {
+            count++;
+            return;
+        }
+        if (name == String::number(count)) {
+            procfd_fd = ProcFSProcessFileDescription::create(count, *file_description_metadata.description(), file_description_metadata.global_procfs_inode_index(), *this);
+        }
+        count++;
+    });
+    return procfd_fd;
+}
+
+class ProcFSProcessUnveil final : public ProcFSProcessInformation {
+public:
+    static NonnullRefPtr<ProcFSProcessUnveil> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessUnveil(parent_folder));
+    }
+
+private:
+    explicit ProcFSProcessUnveil(const ProcFSProcessFolder& parent_folder)
+        : ProcFSProcessInformation("unveil"sv, parent_folder)
+    {
+    }
+    virtual bool output(KBufferBuilder& builder) override
+    {
+        JsonArraySerializer array { builder };
+        for (auto& unveiled_path : m_parent_folder->m_associated_process->unveiled_paths()) {
+            if (!unveiled_path.was_explicitly_unveiled())
+                continue;
+            auto obj = array.add_object();
+            obj.add("path", unveiled_path.path());
+            StringBuilder permissions_builder;
+            if (unveiled_path.permissions() & UnveilAccess::Read)
+                permissions_builder.append('r');
+            if (unveiled_path.permissions() & UnveilAccess::Write)
+                permissions_builder.append('w');
+            if (unveiled_path.permissions() & UnveilAccess::Execute)
+                permissions_builder.append('x');
+            if (unveiled_path.permissions() & UnveilAccess::CreateOrRemove)
+                permissions_builder.append('c');
+            if (unveiled_path.permissions() & UnveilAccess::Browse)
+                permissions_builder.append('b');
+            obj.add("permissions", permissions_builder.to_string());
+        }
+        array.finish();
+        return true;
+    }
+};
+
+class ProcFSProcessPerformanceEvents final : public ProcFSProcessInformation {
+public:
+    static NonnullRefPtr<ProcFSProcessPerformanceEvents> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessPerformanceEvents(parent_folder));
+    }
+
+private:
+    explicit ProcFSProcessPerformanceEvents(const ProcFSProcessFolder& parent_folder)
+        : ProcFSProcessInformation("perf_events"sv, parent_folder)
+    {
+    }
+    virtual bool output(KBufferBuilder& builder) override
+    {
+        InterruptDisabler disabler;
+        if (!m_parent_folder->m_associated_process->perf_events()) {
+            dbgln("ProcFS: No perf events for {}", m_parent_folder->m_associated_process->pid());
+            return false;
+        }
+        return m_parent_folder->m_associated_process->perf_events()->to_json(builder);
+    }
+};
+
+class ProcFSProcessOverallFileDescriptions final : public ProcFSProcessInformation {
+public:
+    static NonnullRefPtr<ProcFSProcessOverallFileDescriptions> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessOverallFileDescriptions(parent_folder));
+    }
+
+private:
+    explicit ProcFSProcessOverallFileDescriptions(const ProcFSProcessFolder& parent_folder)
+        : ProcFSProcessInformation("fds"sv, parent_folder)
+    {
+    }
+    virtual bool output(KBufferBuilder& builder) override
+    {
+        JsonArraySerializer array { builder };
+        auto process = m_parent_folder->m_associated_process;
+        if (process->fds().open_count() == 0) {
+            array.finish();
+            return true;
+        }
+
+        size_t count = 0;
+        process->fds().enumerate([&](auto& file_description_metadata) {
+            if (!file_description_metadata.is_valid()) {
+                count++;
+                return;
+            }
+            bool cloexec = file_description_metadata.flags() & FD_CLOEXEC;
+            RefPtr<FileDescription> description = file_description_metadata.description();
+            auto description_object = array.add_object();
+            description_object.add("fd", count);
+            description_object.add("absolute_path", description->absolute_path());
+            description_object.add("seekable", description->file().is_seekable());
+            description_object.add("class", description->file().class_name());
+            description_object.add("offset", description->offset());
+            description_object.add("cloexec", cloexec);
+            description_object.add("blocking", description->is_blocking());
+            description_object.add("can_read", description->can_read());
+            description_object.add("can_write", description->can_write());
+            count++;
+        });
+
+        array.finish();
+        return true;
+    }
+};
+
+class ProcFSProcessRoot final : public ProcFSExposedLink {
+public:
+    static NonnullRefPtr<ProcFSProcessRoot> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessRoot(parent_folder));
+    }
+
+private:
+    explicit ProcFSProcessRoot(const ProcFSProcessFolder& parent_folder)
+        : ProcFSExposedLink("root"sv)
+        , m_parent_process_directory(parent_folder)
+    {
+    }
+    virtual bool acquire_link(KBufferBuilder& builder) override
+    {
+        builder.append_bytes(m_parent_process_directory->m_associated_process->root_directory_relative_to_global_root().absolute_path().to_byte_buffer());
+        return true;
+    }
+    NonnullRefPtr<ProcFSProcessFolder> m_parent_process_directory;
+};
+
+class ProcFSProcessVirtualMemory final : public ProcFSProcessInformation {
+public:
+    static NonnullRefPtr<ProcFSProcessRoot> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessVirtualMemory(parent_folder));
+    }
+
+private:
+    explicit ProcFSProcessVirtualMemory(const ProcFSProcessFolder& parent_folder)
+        : ProcFSProcessInformation("vm"sv, parent_folder)
+    {
+    }
+    virtual bool output(KBufferBuilder& builder) override
+    {
+        auto process = m_parent_folder->m_associated_process;
+        JsonArraySerializer array { builder };
+        {
+            ScopedSpinLock lock(process->space().get_lock());
+            for (auto& region : process->space().regions()) {
+                if (!region->is_user() && !Process::current()->is_superuser())
+                    continue;
+                auto region_object = array.add_object();
+                region_object.add("readable", region->is_readable());
+                region_object.add("writable", region->is_writable());
+                region_object.add("executable", region->is_executable());
+                region_object.add("stack", region->is_stack());
+                region_object.add("shared", region->is_shared());
+                region_object.add("syscall", region->is_syscall_region());
+                region_object.add("purgeable", region->vmobject().is_anonymous());
+                if (region->vmobject().is_anonymous()) {
+                    region_object.add("volatile", static_cast<const AnonymousVMObject&>(region->vmobject()).is_any_volatile());
+                }
+                region_object.add("cacheable", region->is_cacheable());
+                region_object.add("address", region->vaddr().get());
+                region_object.add("size", region->size());
+                region_object.add("amount_resident", region->amount_resident());
+                region_object.add("amount_dirty", region->amount_dirty());
+                region_object.add("cow_pages", region->cow_pages());
+                region_object.add("name", region->name());
+                region_object.add("vmobject", region->vmobject().class_name());
+
+                StringBuilder pagemap_builder;
+                for (size_t i = 0; i < region->page_count(); ++i) {
+                    auto* page = region->physical_page(i);
+                    if (!page)
+                        pagemap_builder.append('N');
+                    else if (page->is_shared_zero_page() || page->is_lazy_committed_page())
+                        pagemap_builder.append('Z');
+                    else
+                        pagemap_builder.append('P');
+                }
+                region_object.add("pagemap", pagemap_builder.to_string());
+            }
+        }
+        array.finish();
+        return true;
+    }
+};
+
+class ProcFSProcessCurrentWorkDirectory final : public ProcFSExposedLink {
+public:
+    static NonnullRefPtr<ProcFSProcessCurrentWorkDirectory> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessCurrentWorkDirectory(parent_folder));
+    }
+
+private:
+    explicit ProcFSProcessCurrentWorkDirectory(const ProcFSProcessFolder& parent_folder)
+        : ProcFSExposedLink("cwd"sv)
+        , m_parent_process_directory(parent_folder)
+    {
+    }
+    virtual bool acquire_link(KBufferBuilder& builder) override
+    {
+        builder.append_bytes(m_parent_process_directory->m_associated_process->current_directory().absolute_path().bytes());
+        return true;
+    }
+
+    NonnullRefPtr<ProcFSProcessFolder> m_parent_process_directory;
+};
+
+class ProcFSProcessBinary final : public ProcFSExposedLink {
+public:
+    static NonnullRefPtr<ProcFSProcessBinary> create(const ProcFSProcessFolder& parent_folder)
+    {
+        return adopt_ref(*new (nothrow) ProcFSProcessBinary(parent_folder));
+    }
+
+    virtual mode_t required_mode() const override
+    {
+        if (!m_parent_process_directory->m_associated_process->executable())
+            return 0;
+        return ProcFSExposedComponent::required_mode();
+    }
+
+private:
+    explicit ProcFSProcessBinary(const ProcFSProcessFolder& parent_folder)
+        : ProcFSExposedLink("exe"sv)
+        , m_parent_process_directory(parent_folder)
+    {
+    }
+    virtual bool acquire_link(KBufferBuilder& builder) override
+    {
+        auto* custody = m_parent_process_directory->m_associated_process->executable();
+        if (!custody)
+            return false;
+        builder.append(custody->absolute_path().bytes());
+        return true;
+    }
+
+    NonnullRefPtr<ProcFSProcessFolder> m_parent_process_directory;
+};
+
+NonnullRefPtr<ProcFSProcessFolder> ProcFSProcessFolder::create(const Process& process)
+{
+    auto folder = adopt_ref_if_nonnull(new (nothrow) ProcFSProcessFolder(process)).release_nonnull();
+    folder->m_components.append(ProcFSProcessUnveil::create(folder));
+    folder->m_components.append(ProcFSProcessPerformanceEvents::create(folder));
+    folder->m_components.append(ProcFSProcessFileDescriptions::create(folder));
+    folder->m_components.append(ProcFSProcessOverallFileDescriptions::create(folder));
+    folder->m_components.append(ProcFSProcessRoot::create(folder));
+    folder->m_components.append(ProcFSProcessVirtualMemory::create(folder));
+    folder->m_components.append(ProcFSProcessCurrentWorkDirectory::create(folder));
+    folder->m_components.append(ProcFSProcessBinary::create(folder));
+    folder->m_components.append(ProcFSProcessStacks::create(folder));
+    return folder;
+}
+
+ProcFSProcessFolder::ProcFSProcessFolder(const Process& process)
+    : ProcFSExposedFolder(String::formatted("{:d}", process.pid().value()), ProcFSComponentsRegistrar::the().root_folder())
+    , m_associated_process(process)
+{
+}
+
+}