From 722ae35329d2635b4eac6d720299824951a306c3 Mon Sep 17 00:00:00 2001
From: Liav A <liavalb@gmail.com>
Date: Fri, 25 Nov 2022 22:29:27 +0200
Subject: [PATCH] Kernel/FileSystem: Simplify the ProcFS inode code

This is done by merging all scattered pieces of derived classes from the
ProcFSInode class into that one class, so we don't use inheritance but
rather simplistic checks to determine the proper code for each ProcFS
inode with its specific characteristics.
---
 Kernel/CMakeLists.txt                         |   7 -
 Kernel/FileSystem/ProcFS/DirectoryInode.cpp   |  51 --
 Kernel/FileSystem/ProcFS/DirectoryInode.h     |  28 -
 Kernel/FileSystem/ProcFS/FileSystem.cpp       |   4 +-
 Kernel/FileSystem/ProcFS/FileSystem.h         |  12 +-
 Kernel/FileSystem/ProcFS/GlobalInode.cpp      |  88 ---
 Kernel/FileSystem/ProcFS/GlobalInode.h        |  40 --
 Kernel/FileSystem/ProcFS/Inode.cpp            | 501 +++++++++++++++++-
 Kernel/FileSystem/ProcFS/Inode.h              |  74 ++-
 Kernel/FileSystem/ProcFS/LinkInode.cpp        |  36 --
 Kernel/FileSystem/ProcFS/LinkInode.h          |  24 -
 .../ProcFS/ProcessAssociatedInode.cpp         |  24 -
 .../ProcFS/ProcessAssociatedInode.h           |  28 -
 .../ProcFS/ProcessDirectoryInode.cpp          |  95 ----
 .../FileSystem/ProcFS/ProcessDirectoryInode.h |  31 --
 .../ProcFS/ProcessPropertyInode.cpp           | 236 ---------
 .../FileSystem/ProcFS/ProcessPropertyInode.h  |  51 --
 .../ProcFS/ProcessSubDirectoryInode.cpp       |  96 ----
 .../ProcFS/ProcessSubDirectoryInode.h         |  34 --
 Kernel/Forward.h                              |   1 -
 Kernel/Process.h                              |   2 +-
 Kernel/ProcessExposed.cpp                     |  11 +-
 Kernel/ProcessExposed.h                       |   6 +-
 Kernel/ProcessProcFSTraits.cpp                |   6 +-
 Kernel/ProcessSpecificExposed.cpp             |  10 +-
 25 files changed, 583 insertions(+), 913 deletions(-)
 delete mode 100644 Kernel/FileSystem/ProcFS/DirectoryInode.cpp
 delete mode 100644 Kernel/FileSystem/ProcFS/DirectoryInode.h
 delete mode 100644 Kernel/FileSystem/ProcFS/GlobalInode.cpp
 delete mode 100644 Kernel/FileSystem/ProcFS/GlobalInode.h
 delete mode 100644 Kernel/FileSystem/ProcFS/LinkInode.cpp
 delete mode 100644 Kernel/FileSystem/ProcFS/LinkInode.h
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessAssociatedInode.cpp
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessDirectoryInode.cpp
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessDirectoryInode.h
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessPropertyInode.cpp
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessPropertyInode.h
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.cpp
 delete mode 100644 Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.h

diff --git a/Kernel/CMakeLists.txt b/Kernel/CMakeLists.txt
index 48401971fc..fd0babb4b6 100644
--- a/Kernel/CMakeLists.txt
+++ b/Kernel/CMakeLists.txt
@@ -132,15 +132,8 @@ set(KERNEL_SOURCES
     FileSystem/Plan9FS/Inode.cpp
     FileSystem/Plan9FS/Message.cpp
     FileSystem/ProcFS/ComponentRegistry.cpp
-    FileSystem/ProcFS/DirectoryInode.cpp
     FileSystem/ProcFS/FileSystem.cpp
-    FileSystem/ProcFS/GlobalInode.cpp
     FileSystem/ProcFS/Inode.cpp
-    FileSystem/ProcFS/LinkInode.cpp
-    FileSystem/ProcFS/ProcessAssociatedInode.cpp
-    FileSystem/ProcFS/ProcessDirectoryInode.cpp
-    FileSystem/ProcFS/ProcessPropertyInode.cpp
-    FileSystem/ProcFS/ProcessSubDirectoryInode.cpp
     FileSystem/SysFS/Component.cpp
     FileSystem/SysFS/DirectoryInode.cpp
     FileSystem/SysFS/FileSystem.cpp
diff --git a/Kernel/FileSystem/ProcFS/DirectoryInode.cpp b/Kernel/FileSystem/ProcFS/DirectoryInode.cpp
deleted file mode 100644
index 569fa480fd..0000000000
--- a/Kernel/FileSystem/ProcFS/DirectoryInode.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <Kernel/FileSystem/ProcFS/DirectoryInode.h>
-
-namespace Kernel {
-
-ErrorOr<NonnullLockRefPtr<ProcFSDirectoryInode>> ProcFSDirectoryInode::try_create(ProcFS const& procfs, ProcFSExposedComponent const& component)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSDirectoryInode(procfs, component));
-}
-
-ProcFSDirectoryInode::ProcFSDirectoryInode(ProcFS const& fs, ProcFSExposedComponent const& component)
-    : ProcFSGlobalInode(fs, component)
-{
-}
-
-ProcFSDirectoryInode::~ProcFSDirectoryInode() = default;
-
-InodeMetadata ProcFSDirectoryInode::metadata() const
-{
-    MutexLocker locker(m_inode_lock);
-    InodeMetadata metadata;
-    metadata.inode = { fsid(), m_associated_component->component_index() };
-    metadata.mode = S_IFDIR | m_associated_component->required_mode();
-    metadata.uid = m_associated_component->owner_user();
-    metadata.gid = m_associated_component->owner_group();
-    metadata.size = 0;
-    metadata.mtime = m_associated_component->modified_time();
-    return metadata;
-}
-
-ErrorOr<void> ProcFSDirectoryInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
-{
-    MutexLocker locker(procfs().m_lock);
-    return m_associated_component->traverse_as_directory(procfs().fsid(), move(callback));
-}
-
-ErrorOr<NonnullLockRefPtr<Inode>> ProcFSDirectoryInode::lookup(StringView name)
-{
-    MutexLocker locker(procfs().m_lock);
-    auto component = TRY(m_associated_component->lookup(name));
-    return component->to_inode(procfs());
-}
-
-}
diff --git a/Kernel/FileSystem/ProcFS/DirectoryInode.h b/Kernel/FileSystem/ProcFS/DirectoryInode.h
deleted file mode 100644
index 173af61667..0000000000
--- a/Kernel/FileSystem/ProcFS/DirectoryInode.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <Kernel/FileSystem/ProcFS/GlobalInode.h>
-
-namespace Kernel {
-
-class ProcFSDirectoryInode final : public ProcFSGlobalInode {
-    friend class ProcFS;
-
-public:
-    static ErrorOr<NonnullLockRefPtr<ProcFSDirectoryInode>> try_create(ProcFS const&, ProcFSExposedComponent const&);
-    virtual ~ProcFSDirectoryInode() override;
-
-protected:
-    ProcFSDirectoryInode(ProcFS const&, ProcFSExposedComponent const&);
-    // ^Inode
-    virtual InodeMetadata metadata() const override;
-    virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> lookup(StringView name) override;
-};
-
-}
diff --git a/Kernel/FileSystem/ProcFS/FileSystem.cpp b/Kernel/FileSystem/ProcFS/FileSystem.cpp
index 7ea12c6344..e573c3ff37 100644
--- a/Kernel/FileSystem/ProcFS/FileSystem.cpp
+++ b/Kernel/FileSystem/ProcFS/FileSystem.cpp
@@ -6,8 +6,8 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <Kernel/FileSystem/ProcFS/DirectoryInode.h>
 #include <Kernel/FileSystem/ProcFS/FileSystem.h>
+#include <Kernel/FileSystem/ProcFS/Inode.h>
 #include <Kernel/ProcessExposed.h>
 
 namespace Kernel {
@@ -22,7 +22,7 @@ ProcFS::~ProcFS() = default;
 
 ErrorOr<void> ProcFS::initialize()
 {
-    m_root_inode = static_ptr_cast<ProcFSDirectoryInode>(TRY(ProcFSComponentRegistry::the().root_directory().to_inode(*this)));
+    m_root_inode = TRY(ProcFSComponentRegistry::the().root_directory().to_inode(*this));
     return {};
 }
 
diff --git a/Kernel/FileSystem/ProcFS/FileSystem.h b/Kernel/FileSystem/ProcFS/FileSystem.h
index f8d127e3c9..217ab7b7e2 100644
--- a/Kernel/FileSystem/ProcFS/FileSystem.h
+++ b/Kernel/FileSystem/ProcFS/FileSystem.h
@@ -14,18 +14,8 @@
 namespace Kernel {
 
 class ProcFSInode;
-class ProcFSProcessDirectoryInode;
-class ProcFSGlobalInode;
-class ProcFSAssociatedProcessInode;
-class ProcFSProcessSubDirectoryInode;
-
 class ProcFS final : public FileSystem {
     friend class ProcFSInode;
-    friend class ProcFSDirectoryInode;
-    friend class ProcFSProcessDirectoryInode;
-    friend class ProcFSGlobalInode;
-    friend class ProcFSAssociatedProcessInode;
-    friend class ProcFSProcessSubDirectoryInode;
 
 public:
     virtual ~ProcFS() override;
@@ -39,7 +29,7 @@ public:
 private:
     ProcFS();
 
-    LockRefPtr<ProcFSDirectoryInode> m_root_inode;
+    LockRefPtr<ProcFSInode> m_root_inode;
 };
 
 }
diff --git a/Kernel/FileSystem/ProcFS/GlobalInode.cpp b/Kernel/FileSystem/ProcFS/GlobalInode.cpp
deleted file mode 100644
index c0eab41690..0000000000
--- a/Kernel/FileSystem/ProcFS/GlobalInode.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <Kernel/FileSystem/ProcFS/GlobalInode.h>
-
-namespace Kernel {
-
-ErrorOr<NonnullLockRefPtr<ProcFSGlobalInode>> ProcFSGlobalInode::try_create(ProcFS const& fs, ProcFSExposedComponent const& component)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSGlobalInode(fs, component));
-}
-
-ProcFSGlobalInode::ProcFSGlobalInode(ProcFS const& fs, ProcFSExposedComponent const& component)
-    : ProcFSInode(fs, component.component_index())
-    , m_associated_component(component)
-{
-}
-
-void ProcFSGlobalInode::did_seek(OpenFileDescription& description, off_t new_offset)
-{
-    if (new_offset != 0)
-        return;
-    auto result = m_associated_component->refresh_data(description);
-    if (result.is_error()) {
-        // Subsequent calls to read will return EIO!
-        dbgln("ProcFS: Could not refresh contents: {}", result.error());
-    }
-}
-
-ErrorOr<void> ProcFSGlobalInode::attach(OpenFileDescription& description)
-{
-    return m_associated_component->refresh_data(description);
-}
-
-ErrorOr<size_t> ProcFSGlobalInode::read_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
-{
-    return m_associated_component->read_bytes(offset, count, buffer, fd);
-}
-
-StringView ProcFSGlobalInode::name() const
-{
-    return m_associated_component->name();
-}
-
-ErrorOr<void> ProcFSGlobalInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const
-{
-    VERIFY_NOT_REACHED();
-}
-
-ErrorOr<NonnullLockRefPtr<Inode>> ProcFSGlobalInode::lookup(StringView)
-{
-    VERIFY_NOT_REACHED();
-}
-
-ErrorOr<void> ProcFSGlobalInode::truncate(u64 size)
-{
-    return m_associated_component->truncate(size);
-}
-
-ErrorOr<void> ProcFSGlobalInode::update_timestamps(Optional<Time>, Optional<Time>, Optional<Time>)
-{
-    return {};
-}
-
-InodeMetadata ProcFSGlobalInode::metadata() const
-{
-    MutexLocker locker(m_inode_lock);
-    InodeMetadata metadata;
-    metadata.inode = { fsid(), m_associated_component->component_index() };
-    metadata.mode = S_IFREG | m_associated_component->required_mode();
-    metadata.uid = m_associated_component->owner_user();
-    metadata.gid = m_associated_component->owner_group();
-    metadata.size = 0;
-    metadata.mtime = m_associated_component->modified_time();
-    return metadata;
-}
-
-ErrorOr<size_t> ProcFSGlobalInode::write_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* fd)
-{
-    return m_associated_component->write_bytes(offset, count, buffer, fd);
-}
-
-}
diff --git a/Kernel/FileSystem/ProcFS/GlobalInode.h b/Kernel/FileSystem/ProcFS/GlobalInode.h
deleted file mode 100644
index 121ba8ae1c..0000000000
--- a/Kernel/FileSystem/ProcFS/GlobalInode.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <Kernel/FileSystem/ProcFS/FileSystem.h>
-#include <Kernel/FileSystem/ProcFS/Inode.h>
-#include <Kernel/ProcessExposed.h>
-
-namespace Kernel {
-
-class ProcFSGlobalInode : public ProcFSInode {
-    friend class ProcFS;
-
-public:
-    static ErrorOr<NonnullLockRefPtr<ProcFSGlobalInode>> try_create(ProcFS const&, ProcFSExposedComponent const&);
-    virtual ~ProcFSGlobalInode() override {};
-    StringView name() const;
-
-protected:
-    ProcFSGlobalInode(ProcFS const&, ProcFSExposedComponent const&);
-
-    // ^Inode
-    virtual ErrorOr<void> attach(OpenFileDescription& description) override final;
-    virtual ErrorOr<size_t> read_bytes_locked(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual ErrorOr<size_t> write_bytes_locked(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override final;
-    virtual void did_seek(OpenFileDescription&, off_t) override final;
-    virtual InodeMetadata metadata() const override;
-    virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> lookup(StringView) override;
-    virtual ErrorOr<void> truncate(u64) override final;
-    virtual ErrorOr<void> update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime) override;
-
-    NonnullLockRefPtr<ProcFSExposedComponent> m_associated_component;
-};
-
-}
diff --git a/Kernel/FileSystem/ProcFS/Inode.cpp b/Kernel/FileSystem/ProcFS/Inode.cpp
index af3c9e8e46..36b325911c 100644
--- a/Kernel/FileSystem/ProcFS/Inode.cpp
+++ b/Kernel/FileSystem/ProcFS/Inode.cpp
@@ -1,20 +1,17 @@
 /*
  * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ * Copyright (c) 2021-2022, Liav A. <liavalb@hotmail.co.il>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <Kernel/FileSystem/ProcFS/Inode.h>
+#include <Kernel/Process.h>
+#include <Kernel/ProcessExposed.h>
 
 namespace Kernel {
 
-ProcFSInode::ProcFSInode(ProcFS const& fs, InodeIndex index)
-    : Inode(const_cast<ProcFS&>(fs), index)
-{
-}
-
 ProcFSInode::~ProcFSInode() = default;
 
 ErrorOr<void> ProcFSInode::flush_metadata()
@@ -52,4 +49,496 @@ ErrorOr<void> ProcFSInode::replace_child(StringView, Inode&)
     return EROFS;
 }
 
+ErrorOr<size_t> ProcFSInode::write_bytes_locked(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
+{
+    return EROFS;
+}
+
+ErrorOr<void> ProcFSInode::truncate(u64)
+{
+    return EROFS;
+}
+
+ErrorOr<void> ProcFSInode::update_timestamps(Optional<Time>, Optional<Time>, Optional<Time>)
+{
+    // Note: Silently ignore the update request.
+    return {};
+}
+
+static mode_t determine_procfs_process_inode_mode(SegmentedProcFSIndex::ProcessSubDirectory parent_subdirectory_type, Optional<SegmentedProcFSIndex::MainProcessProperty> main_property)
+{
+    if (parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
+        return S_IFLNK | 0400;
+    if (parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
+        return S_IFREG | 0400;
+    if (parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::Children)
+        return S_IFLNK | 0400;
+    VERIFY(parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::Reserved);
+    if (main_property == SegmentedProcFSIndex::MainProcessProperty::BinaryLink)
+        return S_IFLNK | 0777;
+    if (main_property == SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink)
+        return S_IFLNK | 0777;
+    return S_IFREG | 0400;
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_file_description_link_inode(ProcFS const& procfs_instance, unsigned fd_number, ProcessID pid)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, fd_number, pid));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, unsigned file_description_index, ProcessID pid)
+    : Inode(const_cast<ProcFS&>(procfs_instance), SegmentedProcFSIndex::build_segmented_index_for_file_description(pid, file_description_index))
+    , m_type(Type::FileDescriptionLink)
+    , m_parent_subdirectory_type(SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
+    , m_associated_pid(pid)
+{
+    m_possible_data.property_index = file_description_index;
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_thread_stack_inode(ProcFS const& procfs_instance, ThreadID stack_thread_index, ProcessID pid)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, stack_thread_index, pid));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, ThreadID thread_stack_index, ProcessID pid)
+    : Inode(const_cast<ProcFS&>(procfs_instance), SegmentedProcFSIndex::build_segmented_index_for_thread_stack(pid, thread_stack_index))
+    , m_type(Type::ThreadStack)
+    , m_parent_subdirectory_type(SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
+    , m_associated_pid(pid)
+{
+    m_possible_data.property_index = thread_stack_index.value();
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_pid_property_inode(ProcFS const& procfs_instance, SegmentedProcFSIndex::MainProcessProperty process_property, ProcessID pid)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, process_property, pid));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
+    : Inode(const_cast<ProcFS&>(procfs_instance), SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(pid, main_property_type))
+    , m_type(Type::ProcessProperty)
+    , m_parent_subdirectory_type(SegmentedProcFSIndex::ProcessSubDirectory::Reserved)
+    , m_associated_pid(pid)
+{
+    m_possible_data.property_type = main_property_type;
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_child_process_link_inode(ProcFS const& procfs_instance, ProcessID child_pid, ProcessID pid)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, child_pid, pid));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, ProcessID child_pid, ProcessID pid)
+    : Inode(const_cast<ProcFS&>(procfs_instance), SegmentedProcFSIndex::build_segmented_index_for_children(pid, child_pid))
+    , m_type(Type::ChildProcessLink)
+    , m_parent_subdirectory_type(SegmentedProcFSIndex::ProcessSubDirectory::Children)
+    , m_associated_pid(pid)
+{
+    m_possible_data.property_index = child_pid.value();
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_process_directory_inode(ProcFS const& procfs_instance, ProcessID pid)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, pid));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, ProcessID pid)
+    : Inode(const_cast<ProcFS&>(procfs_instance), SegmentedProcFSIndex::build_segmented_index_for_pid_directory(pid))
+    , m_type(Type::ProcessDirectory)
+    , m_associated_pid(pid)
+{
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_process_subdirectory_inode(ProcFS const& procfs_instance, SegmentedProcFSIndex::ProcessSubDirectory subdirectory_type, ProcessID pid)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, subdirectory_type, pid));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, SegmentedProcFSIndex::ProcessSubDirectory subdirectory_type, ProcessID pid)
+    : Inode(const_cast<ProcFS&>(procfs_instance), SegmentedProcFSIndex::build_segmented_index_for_sub_directory(pid, subdirectory_type))
+    , m_type(Type::ProcessSubdirectory)
+    , m_subdirectory_type(subdirectory_type)
+    , m_associated_pid(pid)
+{
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_global_link_inode(ProcFS const& procfs_instance, ProcFSExposedLink const& link_component)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, link_component));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, ProcFSExposedLink const& link_component)
+    : Inode(const_cast<ProcFS&>(procfs_instance), link_component.component_index())
+    , m_type(Type::GlobalLink)
+    , m_associated_component(link_component)
+{
+}
+
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSInode::try_create_as_directory_inode(ProcFS const& procfs_instance, ProcFSExposedDirectory const& directory_component)
+{
+    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSInode(procfs_instance, directory_component));
+}
+
+ProcFSInode::ProcFSInode(ProcFS const& procfs_instance, ProcFSExposedDirectory const& directory_component)
+    : Inode(const_cast<ProcFS&>(procfs_instance), directory_component.component_index())
+    , m_type(Type::GlobalDirectory)
+    , m_associated_component(directory_component)
+{
+}
+
+ErrorOr<void> ProcFSInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
+{
+    MutexLocker locker(procfs().m_lock);
+    if (m_type == Type::ProcessSubdirectory) {
+        VERIFY(m_associated_pid.has_value());
+        VERIFY(m_subdirectory_type.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return EINVAL;
+        switch (m_subdirectory_type.value()) {
+        case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
+            return process->traverse_file_descriptions_directory(procfs().fsid(), move(callback));
+        case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
+            return process->traverse_stacks_directory(procfs().fsid(), move(callback));
+        case SegmentedProcFSIndex::ProcessSubDirectory::Children:
+            return process->traverse_children_directory(procfs().fsid(), move(callback));
+        default:
+            VERIFY_NOT_REACHED();
+        }
+        VERIFY_NOT_REACHED();
+    }
+
+    if (m_type == Type::GlobalDirectory) {
+        VERIFY(m_associated_component);
+        return m_associated_component->traverse_as_directory(procfs().fsid(), move(callback));
+    }
+    VERIFY(m_type == Type::ProcessDirectory);
+    VERIFY(m_associated_pid.has_value());
+    auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+    if (!process)
+        return EINVAL;
+    return process->procfs_traits()->traverse_as_directory(procfs().fsid(), move(callback));
+}
+
+ErrorOr<NonnullLockRefPtr<Inode>> ProcFSInode::lookup(StringView name)
+{
+    MutexLocker locker(procfs().m_lock);
+    if (m_type == Type::ProcessSubdirectory) {
+        VERIFY(m_associated_pid.has_value());
+        VERIFY(m_subdirectory_type.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return ESRCH;
+        switch (m_subdirectory_type.value()) {
+        case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
+            return process->lookup_file_descriptions_directory(procfs(), name);
+        case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
+            return process->lookup_stacks_directory(procfs(), name);
+        case SegmentedProcFSIndex::ProcessSubDirectory::Children:
+            return process->lookup_children_directory(procfs(), name);
+        default:
+            VERIFY_NOT_REACHED();
+        }
+        VERIFY_NOT_REACHED();
+    }
+
+    if (m_type == Type::GlobalDirectory) {
+        VERIFY(m_associated_component);
+        auto component = TRY(m_associated_component->lookup(name));
+        return TRY(component->to_inode(procfs()));
+    }
+
+    VERIFY(m_type == Type::ProcessDirectory);
+    VERIFY(m_associated_pid.has_value());
+    auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+    if (!process)
+        return ESRCH;
+    if (name == "fd"sv)
+        return TRY(ProcFSInode::try_create_as_process_subdirectory_inode(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions, m_associated_pid.value()));
+    if (name == "stacks"sv)
+        return TRY(ProcFSInode::try_create_as_process_subdirectory_inode(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::Stacks, m_associated_pid.value()));
+    if (name == "children"sv)
+        return TRY(ProcFSInode::try_create_as_process_subdirectory_inode(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::Children, m_associated_pid.value()));
+    if (name == "unveil"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::Unveil, m_associated_pid.value()));
+    if (name == "pledge"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::Pledge, m_associated_pid.value()));
+    if (name == "fds"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions, m_associated_pid.value()));
+    if (name == "exe"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::BinaryLink, m_associated_pid.value()));
+    if (name == "cwd"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink, m_associated_pid.value()));
+    if (name == "perf_events"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents, m_associated_pid.value()));
+    if (name == "vm"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::VirtualMemoryStats, m_associated_pid.value()));
+    if (name == "cmdline"sv)
+        return TRY(ProcFSInode::try_create_as_pid_property_inode(procfs(), SegmentedProcFSIndex::MainProcessProperty::CommandLine, m_associated_pid.value()));
+    return ENOENT;
+}
+
+ErrorOr<void> ProcFSInode::attach(OpenFileDescription& description)
+{
+    if (m_type == Type::GlobalDirectory || m_type == Type::ProcessDirectory || m_type == Type::ProcessSubdirectory)
+        return {};
+    if (m_type == Type::GlobalLink)
+        return m_associated_component->refresh_data(description);
+    VERIFY(m_type == Type::ProcessProperty || m_type == Type::FileDescriptionLink || m_type == Type::ThreadStack || m_type == Type::ChildProcessLink);
+    return refresh_process_property_data(description);
+}
+
+void ProcFSInode::did_seek(OpenFileDescription& description, off_t offset)
+{
+    if (m_type == Type::GlobalLink) {
+        if (offset != 0)
+            return;
+        auto result = m_associated_component->refresh_data(description);
+        if (result.is_error()) {
+            // Subsequent calls to read will return EIO!
+            dbgln("ProcFS: Could not refresh contents: {}", result.error());
+        }
+    }
+    VERIFY(m_type == Type::ProcessProperty || m_type == Type::FileDescriptionLink || m_type == Type::ThreadStack || m_type == Type::ChildProcessLink);
+    if (offset != 0)
+        return;
+    (void)refresh_process_property_data(description);
+}
+
+ErrorOr<size_t> ProcFSInode::read_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
+{
+    dbgln_if(PROCFS_DEBUG, "ProcFSInode: read_bytes_locked offset: {} count: {}", offset, count);
+    if (m_type == Type::GlobalLink) {
+        VERIFY(m_associated_component);
+        return m_associated_component->read_bytes(offset, count, buffer, description);
+    }
+
+    VERIFY(m_type == Type::ProcessProperty || m_type == Type::FileDescriptionLink || m_type == Type::ThreadStack || m_type == Type::ChildProcessLink);
+    VERIFY(offset >= 0);
+    VERIFY(buffer.user_or_kernel_ptr());
+
+    if (!description) {
+        auto builder = TRY(KBufferBuilder::try_create());
+        VERIFY(m_associated_pid.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return Error::from_errno(ESRCH);
+        TRY(try_fetch_process_property_data(*process, builder));
+        auto data_buffer = builder.build();
+        if (!data_buffer)
+            return Error::from_errno(EFAULT);
+        ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
+        TRY(buffer.write(data_buffer->data() + offset, nread));
+        return nread;
+    }
+    if (!description->data()) {
+        dbgln("ProcFS Process Information: Do not have cached data!");
+        return Error::from_errno(EIO);
+    }
+
+    MutexLocker locker(m_refresh_lock);
+
+    auto& typed_cached_data = static_cast<ProcFSInodeData&>(*description->data());
+    auto& data_buffer = typed_cached_data.buffer;
+
+    if (!data_buffer || (size_t)offset >= data_buffer->size())
+        return 0;
+
+    ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
+    TRY(buffer.write(data_buffer->data() + offset, nread));
+
+    return nread;
+}
+
+static ErrorOr<void> build_from_cached_data(KBufferBuilder& builder, ProcFSInodeData& cached_data)
+{
+    cached_data.buffer = builder.build();
+    if (!cached_data.buffer)
+        return ENOMEM;
+    return {};
+}
+
+ErrorOr<void> ProcFSInode::try_fetch_process_property_data(NonnullLockRefPtr<Process> process, KBufferBuilder& builder) const
+{
+    VERIFY(m_type == Type::ProcessProperty || m_type == Type::FileDescriptionLink || m_type == Type::ThreadStack || m_type == Type::ChildProcessLink);
+    VERIFY(m_parent_subdirectory_type.has_value());
+    auto parent_subdirectory_type = m_parent_subdirectory_type.value();
+    if (parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions) {
+        TRY(process->procfs_get_file_description_link(m_possible_data.property_index, builder));
+        return {};
+    }
+    if (parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks) {
+        TRY(process->procfs_get_thread_stack(m_possible_data.property_index, builder));
+        return {};
+    }
+    if (parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::Children) {
+        TRY(process->procfs_get_child_proccess_link(m_possible_data.property_index, builder));
+        return {};
+    }
+
+    VERIFY(m_type == Type::ProcessProperty);
+    VERIFY(parent_subdirectory_type == SegmentedProcFSIndex::ProcessSubDirectory::Reserved);
+    switch (m_possible_data.property_type) {
+    case SegmentedProcFSIndex::MainProcessProperty::Unveil:
+        return process->procfs_get_unveil_stats(builder);
+    case SegmentedProcFSIndex::MainProcessProperty::Pledge:
+        return process->procfs_get_pledge_stats(builder);
+    case SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions:
+        return process->procfs_get_fds_stats(builder);
+    case SegmentedProcFSIndex::MainProcessProperty::BinaryLink:
+        return process->procfs_get_binary_link(builder);
+    case SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink:
+        return process->procfs_get_current_work_directory_link(builder);
+    case SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents:
+        return process->procfs_get_perf_events(builder);
+    case SegmentedProcFSIndex::MainProcessProperty::VirtualMemoryStats:
+        return process->procfs_get_virtual_memory_stats(builder);
+    case SegmentedProcFSIndex::MainProcessProperty::CommandLine:
+        return process->procfs_get_command_line(builder);
+    default:
+        VERIFY_NOT_REACHED();
+    }
+}
+
+ErrorOr<void> ProcFSInode::refresh_process_property_data(OpenFileDescription& description)
+{
+    // For process-specific inodes, hold the process's ptrace lock across refresh
+    // and refuse to load data if the process is not dumpable.
+    // Without this, files opened before a process went non-dumpable could still be used for dumping.
+    VERIFY(m_type == Type::ProcessProperty || m_type == Type::FileDescriptionLink || m_type == Type::ThreadStack || m_type == Type::ChildProcessLink);
+    VERIFY(m_associated_pid.has_value());
+    auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+    if (!process)
+        return Error::from_errno(ESRCH);
+    process->ptrace_lock().lock();
+    if (!process->is_dumpable()) {
+        process->ptrace_lock().unlock();
+        return EPERM;
+    }
+    ScopeGuard guard = [&] {
+        process->ptrace_lock().unlock();
+    };
+    MutexLocker locker(m_refresh_lock);
+    auto& cached_data = description.data();
+    if (!cached_data) {
+        cached_data = adopt_own_if_nonnull(new (nothrow) ProcFSInodeData);
+        if (!cached_data)
+            return ENOMEM;
+    }
+    auto builder = TRY(KBufferBuilder::try_create());
+    TRY(try_fetch_process_property_data(*process, builder));
+    return build_from_cached_data(builder, static_cast<ProcFSInodeData&>(*cached_data));
+}
+
+InodeMetadata ProcFSInode::metadata() const
+{
+    InodeMetadata metadata;
+    switch (m_type) {
+    case Type::GlobalLink: {
+        metadata.inode = { fsid(), m_associated_component->component_index() };
+        metadata.mode = S_IFLNK | m_associated_component->required_mode();
+        metadata.uid = m_associated_component->owner_user();
+        metadata.gid = m_associated_component->owner_group();
+        metadata.size = 0;
+        metadata.mtime = m_associated_component->modified_time();
+        break;
+    }
+    case Type::GlobalDirectory: {
+        metadata.inode = { fsid(), m_associated_component->component_index() };
+        metadata.mode = S_IFDIR | m_associated_component->required_mode();
+        metadata.uid = m_associated_component->owner_user();
+        metadata.gid = m_associated_component->owner_group();
+        metadata.size = 0;
+        metadata.mtime = m_associated_component->modified_time();
+        break;
+    }
+    case Type::FileDescriptionLink: {
+        VERIFY(m_associated_pid.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return {};
+        auto traits = process->procfs_traits();
+        metadata.inode = { fsid(), SegmentedProcFSIndex::build_segmented_index_for_file_description(m_associated_pid.value(), m_possible_data.property_index) };
+        metadata.mode = determine_procfs_process_inode_mode(m_parent_subdirectory_type.value(), {});
+        metadata.uid = traits->owner_user();
+        metadata.gid = traits->owner_group();
+        metadata.size = 0;
+        metadata.mtime = traits->modified_time();
+        break;
+    }
+    case Type::ThreadStack: {
+        VERIFY(m_associated_pid.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return {};
+        auto traits = process->procfs_traits();
+        metadata.inode = { fsid(), SegmentedProcFSIndex::build_segmented_index_for_thread_stack(m_associated_pid.value(), m_possible_data.property_index) };
+        metadata.mode = determine_procfs_process_inode_mode(m_parent_subdirectory_type.value(), {});
+        metadata.uid = traits->owner_user();
+        metadata.gid = traits->owner_group();
+        metadata.size = 0;
+        metadata.mtime = traits->modified_time();
+        break;
+    }
+    case Type::ProcessProperty: {
+        VERIFY(m_associated_pid.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return {};
+        auto traits = process->procfs_traits();
+        metadata.inode = { fsid(), SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(m_associated_pid.value(), m_possible_data.property_type) };
+        metadata.mode = determine_procfs_process_inode_mode(m_parent_subdirectory_type.value(), m_possible_data.property_type);
+        metadata.uid = traits->owner_user();
+        metadata.gid = traits->owner_group();
+        metadata.size = 0;
+        metadata.mtime = traits->modified_time();
+        break;
+    }
+    case Type::ChildProcessLink: {
+        VERIFY(m_associated_pid.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return {};
+        auto traits = process->procfs_traits();
+        metadata.inode = { fsid(), SegmentedProcFSIndex::build_segmented_index_for_children(m_associated_pid.value(), m_possible_data.property_index) };
+        metadata.mode = determine_procfs_process_inode_mode(m_parent_subdirectory_type.value(), {});
+        metadata.uid = traits->owner_user();
+        metadata.gid = traits->owner_group();
+        metadata.size = 0;
+        metadata.mtime = traits->modified_time();
+        break;
+    }
+    case Type::ProcessDirectory: {
+        VERIFY(m_associated_pid.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return {};
+        auto traits = process->procfs_traits();
+        metadata.inode = { fsid(), traits->component_index() };
+        metadata.mode = S_IFDIR | traits->required_mode();
+        metadata.uid = traits->owner_user();
+        metadata.gid = traits->owner_group();
+        metadata.size = 0;
+        metadata.mtime = traits->modified_time();
+        break;
+    }
+    case Type::ProcessSubdirectory: {
+        VERIFY(m_associated_pid.has_value());
+        VERIFY(m_subdirectory_type.has_value());
+        auto process = Process::from_pid_in_same_jail(m_associated_pid.value());
+        if (!process)
+            return {};
+        auto traits = process->procfs_traits();
+        metadata.inode = { fsid(), SegmentedProcFSIndex::build_segmented_index_for_sub_directory(m_associated_pid.value(), m_subdirectory_type.value()) };
+        metadata.mode = S_IFDIR | traits->required_mode();
+        metadata.uid = traits->owner_user();
+        metadata.gid = traits->owner_group();
+        metadata.size = 0;
+        metadata.mtime = traits->modified_time();
+        break;
+    }
+    }
+    return metadata;
+}
+
 }
diff --git a/Kernel/FileSystem/ProcFS/Inode.h b/Kernel/FileSystem/ProcFS/Inode.h
index 799e36808b..1628824d18 100644
--- a/Kernel/FileSystem/ProcFS/Inode.h
+++ b/Kernel/FileSystem/ProcFS/Inode.h
@@ -14,28 +14,90 @@
 
 namespace Kernel {
 
-class ProcFSInode : public Inode {
+class ProcFSExposedDirectory;
+class ProcFSExposedLink;
+class ProcFSInode final : public Inode {
     friend class ProcFS;
 
 public:
+    enum class Type {
+        GlobalLink,
+        GlobalDirectory,
+        FileDescriptionLink,
+        ThreadStack,
+        ProcessProperty,
+        ChildProcessLink,
+        ProcessDirectory,
+        ProcessSubdirectory,
+    };
+
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_file_description_link_inode(ProcFS const&, unsigned, ProcessID);
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_thread_stack_inode(ProcFS const&, ThreadID, ProcessID);
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_pid_property_inode(ProcFS const&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_child_process_link_inode(ProcFS const&, ProcessID, ProcessID);
+
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_process_directory_inode(ProcFS const&, ProcessID);
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_process_subdirectory_inode(ProcFS const&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
+
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_directory_inode(ProcFS const&, ProcFSExposedDirectory const&);
+    static ErrorOr<NonnullLockRefPtr<ProcFSInode>> try_create_as_global_link_inode(ProcFS const&, ProcFSExposedLink const&);
+
     virtual ~ProcFSInode() override;
 
-protected:
-    ProcFSInode(ProcFS const&, InodeIndex);
+private:
+    // ProcFS PID property inode (/proc/PID/PROPERTY)
+    ProcFSInode(ProcFS const&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
+    // ProcFS Thread stack inode (/proc/PID/stacks/TID)
+    ProcFSInode(ProcFS const&, ThreadID, ProcessID);
+    // ProcFS File description link inode (/proc/PID/fd/FD)
+    ProcFSInode(ProcFS const&, unsigned, ProcessID);
+    // ProcFS Child process link inode (/proc/PID/children/CHILD_PID)
+    ProcFSInode(ProcFS const&, ProcessID, ProcessID);
+    // ProcFS Process directory inode (/proc/PID/)
+    ProcFSInode(ProcFS const&, ProcessID);
+    // ProcFS Process sub directory inode (/proc/PID/SUBDIRECTORY)
+    ProcFSInode(ProcFS const&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
+
+    ProcFSInode(ProcFS const&, ProcFSExposedLink const&);
+    ProcFSInode(ProcFS const&, ProcFSExposedDirectory const&);
 
     ProcFS& procfs() { return static_cast<ProcFS&>(Inode::fs()); }
     ProcFS const& procfs() const { return static_cast<ProcFS const&>(Inode::fs()); }
 
     // ^Inode
-    virtual ErrorOr<void> attach(OpenFileDescription& description) override = 0;
-    virtual void did_seek(OpenFileDescription&, off_t) override = 0;
+    virtual ErrorOr<void> attach(OpenFileDescription& description) override;
+    virtual void did_seek(OpenFileDescription&, off_t) override;
     virtual ErrorOr<void> flush_metadata() override final;
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override final;
+    virtual ErrorOr<NonnullLockRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
     virtual ErrorOr<void> add_child(Inode&, StringView name, mode_t) override final;
     virtual ErrorOr<void> remove_child(StringView name) override final;
     virtual ErrorOr<void> replace_child(StringView name, Inode& child) override final;
     virtual ErrorOr<void> chmod(mode_t) override final;
     virtual ErrorOr<void> chown(UserID, GroupID) override final;
+    virtual InodeMetadata metadata() const override;
+    virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<size_t> read_bytes_locked(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> write_bytes_locked(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override;
+    virtual ErrorOr<NonnullLockRefPtr<Inode>> lookup(StringView name) override final;
+    virtual ErrorOr<void> truncate(u64) override final;
+    virtual ErrorOr<void> update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime) override;
+
+    ErrorOr<void> refresh_process_property_data(OpenFileDescription& description);
+    ErrorOr<void> try_fetch_process_property_data(NonnullLockRefPtr<Process>, KBufferBuilder& builder) const;
+
+    Type m_type;
+
+    union {
+        SegmentedProcFSIndex::MainProcessProperty property_type;
+        unsigned property_index;
+    } m_possible_data;
+    Optional<SegmentedProcFSIndex::ProcessSubDirectory> const m_parent_subdirectory_type {};
+    Optional<SegmentedProcFSIndex::ProcessSubDirectory> const m_subdirectory_type {};
+
+    Optional<ProcessID> const m_associated_pid {};
+
+    LockRefPtr<ProcFSExposedComponent> m_associated_component;
+    mutable Mutex m_refresh_lock;
 };
 
 }
diff --git a/Kernel/FileSystem/ProcFS/LinkInode.cpp b/Kernel/FileSystem/ProcFS/LinkInode.cpp
deleted file mode 100644
index 4331d0b2a0..0000000000
--- a/Kernel/FileSystem/ProcFS/LinkInode.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <Kernel/FileSystem/ProcFS/LinkInode.h>
-
-namespace Kernel {
-
-ErrorOr<NonnullLockRefPtr<ProcFSLinkInode>> ProcFSLinkInode::try_create(ProcFS const& procfs, ProcFSExposedComponent const& component)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSLinkInode(procfs, component));
-}
-
-ProcFSLinkInode::ProcFSLinkInode(ProcFS const& fs, ProcFSExposedComponent const& component)
-    : ProcFSGlobalInode(fs, component)
-{
-}
-
-InodeMetadata ProcFSLinkInode::metadata() const
-{
-    MutexLocker locker(m_inode_lock);
-    InodeMetadata metadata;
-    metadata.inode = { fsid(), m_associated_component->component_index() };
-    metadata.mode = S_IFLNK | m_associated_component->required_mode();
-    metadata.uid = m_associated_component->owner_user();
-    metadata.gid = m_associated_component->owner_group();
-    metadata.size = 0;
-    metadata.mtime = m_associated_component->modified_time();
-    return metadata;
-}
-
-}
diff --git a/Kernel/FileSystem/ProcFS/LinkInode.h b/Kernel/FileSystem/ProcFS/LinkInode.h
deleted file mode 100644
index 8b80471314..0000000000
--- a/Kernel/FileSystem/ProcFS/LinkInode.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <Kernel/FileSystem/ProcFS/GlobalInode.h>
-
-namespace Kernel {
-
-class ProcFSLinkInode : public ProcFSGlobalInode {
-    friend class ProcFS;
-
-public:
-    static ErrorOr<NonnullLockRefPtr<ProcFSLinkInode>> try_create(ProcFS const&, ProcFSExposedComponent const&);
-
-protected:
-    ProcFSLinkInode(ProcFS const&, ProcFSExposedComponent const&);
-    virtual InodeMetadata metadata() const override;
-};
-
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessAssociatedInode.cpp b/Kernel/FileSystem/ProcFS/ProcessAssociatedInode.cpp
deleted file mode 100644
index 627a2fa980..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessAssociatedInode.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h>
-
-namespace Kernel {
-
-ProcFSProcessAssociatedInode::ProcFSProcessAssociatedInode(ProcFS const& fs, ProcessID associated_pid, InodeIndex determined_index)
-    : ProcFSInode(fs, determined_index)
-    , m_pid(associated_pid)
-{
-}
-
-ErrorOr<size_t> ProcFSProcessAssociatedInode::write_bytes_locked(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
-{
-    return ENOTSUP;
-}
-
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h b/Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h
deleted file mode 100644
index 34a9ca1448..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <Kernel/FileSystem/ProcFS/Inode.h>
-#include <Kernel/Forward.h>
-
-namespace Kernel {
-
-class ProcFSProcessAssociatedInode : public ProcFSInode {
-    friend class ProcFS;
-
-protected:
-    ProcFSProcessAssociatedInode(ProcFS const&, ProcessID, InodeIndex);
-    ProcessID associated_pid() const { return m_pid; }
-
-    // ^Inode
-    virtual ErrorOr<size_t> write_bytes_locked(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override final;
-
-private:
-    const ProcessID m_pid;
-};
-
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessDirectoryInode.cpp b/Kernel/FileSystem/ProcFS/ProcessDirectoryInode.cpp
deleted file mode 100644
index a8e4593c6e..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessDirectoryInode.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <Kernel/FileSystem/ProcFS/ProcessDirectoryInode.h>
-#include <Kernel/FileSystem/ProcFS/ProcessPropertyInode.h>
-#include <Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.h>
-#include <Kernel/Process.h>
-#include <Kernel/ProcessExposed.h>
-
-namespace Kernel {
-
-ErrorOr<NonnullLockRefPtr<ProcFSProcessDirectoryInode>> ProcFSProcessDirectoryInode::try_create(ProcFS const& procfs, ProcessID pid)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessDirectoryInode(procfs, pid));
-}
-
-ProcFSProcessDirectoryInode::ProcFSProcessDirectoryInode(ProcFS const& procfs, ProcessID pid)
-    : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_pid_directory(pid))
-{
-}
-
-ErrorOr<void> ProcFSProcessDirectoryInode::attach(OpenFileDescription&)
-{
-    return {};
-}
-
-InodeMetadata ProcFSProcessDirectoryInode::metadata() const
-{
-    MutexLocker locker(m_inode_lock);
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return {};
-
-    auto traits = process->procfs_traits();
-    InodeMetadata metadata;
-    metadata.inode = { fsid(), traits->component_index() };
-    metadata.mode = S_IFDIR | traits->required_mode();
-    metadata.uid = traits->owner_user();
-    metadata.gid = traits->owner_group();
-    metadata.size = 0;
-    metadata.mtime = traits->modified_time();
-    return metadata;
-}
-
-ErrorOr<size_t> ProcFSProcessDirectoryInode::read_bytes_locked(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
-{
-    VERIFY_NOT_REACHED();
-}
-
-ErrorOr<void> ProcFSProcessDirectoryInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
-{
-    MutexLocker locker(procfs().m_lock);
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return EINVAL;
-    return process->procfs_traits()->traverse_as_directory(procfs().fsid(), move(callback));
-}
-
-ErrorOr<NonnullLockRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView name)
-{
-    MutexLocker locker(procfs().m_lock);
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return ESRCH;
-    if (name == "fd"sv)
-        return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions, associated_pid()));
-    if (name == "stacks"sv)
-        return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::Stacks, associated_pid()));
-    if (name == "children"sv)
-        return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::Children, associated_pid()));
-    if (name == "unveil"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::Unveil, associated_pid()));
-    if (name == "pledge"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::Pledge, associated_pid()));
-    if (name == "fds"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions, associated_pid()));
-    if (name == "exe"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::BinaryLink, associated_pid()));
-    if (name == "cwd"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink, associated_pid()));
-    if (name == "perf_events"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents, associated_pid()));
-    if (name == "vm"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::VirtualMemoryStats, associated_pid()));
-    if (name == "cmdline"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::CommandLine, associated_pid()));
-    return ENOENT;
-}
-
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessDirectoryInode.h b/Kernel/FileSystem/ProcFS/ProcessDirectoryInode.h
deleted file mode 100644
index e3e9fb758a..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessDirectoryInode.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h>
-#include <Kernel/Forward.h>
-
-namespace Kernel {
-
-class ProcFSProcessDirectoryInode final : public ProcFSProcessAssociatedInode {
-    friend class ProcFS;
-
-public:
-    static ErrorOr<NonnullLockRefPtr<ProcFSProcessDirectoryInode>> try_create(ProcFS const&, ProcessID);
-
-private:
-    ProcFSProcessDirectoryInode(ProcFS const&, ProcessID);
-    // ^Inode
-    virtual ErrorOr<void> attach(OpenFileDescription& description) override;
-    virtual void did_seek(OpenFileDescription&, off_t) override { }
-    virtual InodeMetadata metadata() const override;
-    virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual ErrorOr<size_t> read_bytes_locked(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> lookup(StringView name) override;
-};
-
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessPropertyInode.cpp b/Kernel/FileSystem/ProcFS/ProcessPropertyInode.cpp
deleted file mode 100644
index 5e701615b1..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessPropertyInode.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <Kernel/API/POSIX/errno.h>
-#include <Kernel/Debug.h>
-#include <Kernel/FileSystem/OpenFileDescription.h>
-#include <Kernel/FileSystem/ProcFS/ProcessPropertyInode.h>
-#include <Kernel/Process.h>
-#include <Kernel/ProcessExposed.h>
-
-namespace Kernel {
-
-ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_file_description_link(ProcFS const& procfs, unsigned file_description_index, ProcessID pid)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, file_description_index, pid));
-}
-
-ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_thread_stack(ProcFS const& procfs, ThreadID stack_thread_index, ProcessID pid)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, stack_thread_index, pid));
-}
-
-ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_pid_property(ProcFS const& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, main_property_type, pid));
-}
-
-ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_child_process_link(ProcFS const& procfs, ProcessID child_pid, ProcessID pid)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, child_pid, pid));
-}
-
-ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
-    : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(pid, main_property_type))
-    , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Reserved)
-{
-    m_possible_data.property_type = main_property_type;
-}
-
-ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, unsigned file_description_index, ProcessID pid)
-    : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_file_description(pid, file_description_index))
-    , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
-{
-    m_possible_data.property_index = file_description_index;
-}
-
-ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, ThreadID thread_stack_index, ProcessID pid)
-    : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_thread_stack(pid, thread_stack_index))
-    , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
-{
-    m_possible_data.property_index = thread_stack_index.value();
-}
-
-ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, ProcessID child_pid, ProcessID pid)
-    : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_children(pid, child_pid))
-    , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Children)
-{
-    m_possible_data.property_index = child_pid.value();
-}
-
-ErrorOr<void> ProcFSProcessPropertyInode::attach(OpenFileDescription& description)
-{
-    return refresh_data(description);
-}
-
-void ProcFSProcessPropertyInode::did_seek(OpenFileDescription& description, off_t offset)
-{
-    if (offset != 0)
-        return;
-    (void)refresh_data(description);
-}
-
-static mode_t determine_procfs_process_inode_mode(SegmentedProcFSIndex::ProcessSubDirectory parent_sub_directory_type, SegmentedProcFSIndex::MainProcessProperty main_property)
-{
-    if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
-        return S_IFLNK | 0400;
-    if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
-        return S_IFREG | 0400;
-    if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Children)
-        return S_IFLNK | 0400;
-    VERIFY(parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Reserved);
-    if (main_property == SegmentedProcFSIndex::MainProcessProperty::BinaryLink)
-        return S_IFLNK | 0777;
-    if (main_property == SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink)
-        return S_IFLNK | 0777;
-    return S_IFREG | 0400;
-}
-
-InodeMetadata ProcFSProcessPropertyInode::metadata() const
-{
-    MutexLocker locker(m_inode_lock);
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return {};
-
-    auto traits = process->procfs_traits();
-    InodeMetadata metadata;
-    metadata.inode = { fsid(), traits->component_index() };
-    metadata.mode = determine_procfs_process_inode_mode(m_parent_sub_directory_type, m_possible_data.property_type);
-    metadata.uid = traits->owner_user();
-    metadata.gid = traits->owner_group();
-    metadata.size = 0;
-    metadata.mtime = traits->modified_time();
-    return metadata;
-}
-
-ErrorOr<void> ProcFSProcessPropertyInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const
-{
-    VERIFY_NOT_REACHED();
-}
-
-ErrorOr<size_t> ProcFSProcessPropertyInode::read_bytes_locked(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
-{
-    dbgln_if(PROCFS_DEBUG, "ProcFS ProcessInformation: read_bytes_locked offset: {} count: {}", offset, count);
-
-    VERIFY(offset >= 0);
-    VERIFY(buffer.user_or_kernel_ptr());
-
-    if (!description) {
-        auto builder = TRY(KBufferBuilder::try_create());
-        auto process = Process::from_pid_in_same_jail(associated_pid());
-        if (!process)
-            return Error::from_errno(ESRCH);
-        TRY(try_to_acquire_data(*process, builder));
-        auto data_buffer = builder.build();
-        if (!data_buffer)
-            return Error::from_errno(EFAULT);
-        ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
-        TRY(buffer.write(data_buffer->data() + offset, nread));
-        return nread;
-    }
-    if (!description->data()) {
-        dbgln("ProcFS Process Information: Do not have cached data!");
-        return Error::from_errno(EIO);
-    }
-
-    MutexLocker locker(m_refresh_lock);
-
-    auto& typed_cached_data = static_cast<ProcFSInodeData&>(*description->data());
-    auto& data_buffer = typed_cached_data.buffer;
-
-    if (!data_buffer || (size_t)offset >= data_buffer->size())
-        return 0;
-
-    ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
-    TRY(buffer.write(data_buffer->data() + offset, nread));
-
-    return nread;
-}
-
-ErrorOr<NonnullLockRefPtr<Inode>> ProcFSProcessPropertyInode::lookup(StringView)
-{
-    return EINVAL;
-}
-
-static ErrorOr<void> build_from_cached_data(KBufferBuilder& builder, ProcFSInodeData& cached_data)
-{
-    cached_data.buffer = builder.build();
-    if (!cached_data.buffer)
-        return ENOMEM;
-    return {};
-}
-
-ErrorOr<void> ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBufferBuilder& builder) const
-{
-    // FIXME: Verify process is already ref-counted
-    if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions) {
-        TRY(process.procfs_get_file_description_link(m_possible_data.property_index, builder));
-        return {};
-    }
-    if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks) {
-        TRY(process.procfs_get_thread_stack(m_possible_data.property_index, builder));
-        return {};
-    }
-    if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Children) {
-        TRY(process.procfs_get_child_proccess_link(m_possible_data.property_index, builder));
-        return {};
-    }
-
-    VERIFY(m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Reserved);
-    switch (m_possible_data.property_type) {
-    case SegmentedProcFSIndex::MainProcessProperty::Unveil:
-        return process.procfs_get_unveil_stats(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::Pledge:
-        return process.procfs_get_pledge_stats(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions:
-        return process.procfs_get_fds_stats(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::BinaryLink:
-        return process.procfs_get_binary_link(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink:
-        return process.procfs_get_current_work_directory_link(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents:
-        return process.procfs_get_perf_events(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::VirtualMemoryStats:
-        return process.procfs_get_virtual_memory_stats(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::CommandLine:
-        return process.procfs_get_command_line(builder);
-    default:
-        VERIFY_NOT_REACHED();
-    }
-}
-
-ErrorOr<void> ProcFSProcessPropertyInode::refresh_data(OpenFileDescription& description)
-{
-    // For process-specific inodes, hold the process's ptrace lock across refresh
-    // and refuse to load data if the process is not dumpable.
-    // Without this, files opened before a process went non-dumpable could still be used for dumping.
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return Error::from_errno(ESRCH);
-    process->ptrace_lock().lock();
-    if (!process->is_dumpable()) {
-        process->ptrace_lock().unlock();
-        return EPERM;
-    }
-    ScopeGuard guard = [&] {
-        process->ptrace_lock().unlock();
-    };
-    MutexLocker locker(m_refresh_lock);
-    auto& cached_data = description.data();
-    if (!cached_data) {
-        cached_data = adopt_own_if_nonnull(new (nothrow) ProcFSInodeData);
-        if (!cached_data)
-            return ENOMEM;
-    }
-    auto builder = TRY(KBufferBuilder::try_create());
-    TRY(try_to_acquire_data(*process, builder));
-    return build_from_cached_data(builder, static_cast<ProcFSInodeData&>(*cached_data));
-}
-
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessPropertyInode.h b/Kernel/FileSystem/ProcFS/ProcessPropertyInode.h
deleted file mode 100644
index 9340d63080..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessPropertyInode.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h>
-#include <Kernel/Forward.h>
-#include <Kernel/KBufferBuilder.h>
-#include <Kernel/Locking/Mutex.h>
-#include <Kernel/ProcessExposed.h>
-#include <Kernel/UnixTypes.h>
-
-namespace Kernel {
-
-class ProcFSProcessPropertyInode final : public ProcFSProcessAssociatedInode {
-    friend class ProcFS;
-
-public:
-    static ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> try_create_for_file_description_link(ProcFS const&, unsigned, ProcessID);
-    static ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> try_create_for_thread_stack(ProcFS const&, ThreadID, ProcessID);
-    static ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> try_create_for_pid_property(ProcFS const&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
-    static ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> try_create_for_child_process_link(ProcFS const&, ProcessID, ProcessID);
-
-private:
-    ProcFSProcessPropertyInode(ProcFS const&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
-    ProcFSProcessPropertyInode(ProcFS const&, ThreadID, ProcessID);
-    ProcFSProcessPropertyInode(ProcFS const&, unsigned, ProcessID);
-    ProcFSProcessPropertyInode(ProcFS const&, ProcessID, ProcessID);
-
-    // ^Inode
-    virtual ErrorOr<void> attach(OpenFileDescription& description) override;
-    virtual void did_seek(OpenFileDescription&, off_t) override;
-    virtual InodeMetadata metadata() const override;
-    virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual ErrorOr<size_t> read_bytes_locked(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> lookup(StringView name) override final;
-
-    ErrorOr<void> refresh_data(OpenFileDescription& description);
-    ErrorOr<void> try_to_acquire_data(Process& process, KBufferBuilder& builder) const;
-
-    const SegmentedProcFSIndex::ProcessSubDirectory m_parent_sub_directory_type;
-    union {
-        SegmentedProcFSIndex::MainProcessProperty property_type;
-        unsigned property_index;
-    } m_possible_data;
-    mutable Mutex m_refresh_lock;
-};
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.cpp b/Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.cpp
deleted file mode 100644
index 843daede7d..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- * Copyright (c) 2021, Spencer Dixon <spencercdixon@gmail.com>
- * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.h>
-#include <Kernel/Process.h>
-#include <Kernel/ProcessExposed.h>
-
-namespace Kernel {
-
-ErrorOr<NonnullLockRefPtr<ProcFSProcessSubDirectoryInode>> ProcFSProcessSubDirectoryInode::try_create(ProcFS const& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
-{
-    return adopt_nonnull_lock_ref_or_enomem(new (nothrow) ProcFSProcessSubDirectoryInode(procfs, sub_directory_type, pid));
-}
-
-ProcFSProcessSubDirectoryInode::ProcFSProcessSubDirectoryInode(ProcFS const& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
-    : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_sub_directory(pid, sub_directory_type))
-    , m_sub_directory_type(sub_directory_type)
-{
-}
-
-ErrorOr<size_t> ProcFSProcessSubDirectoryInode::read_bytes_locked(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
-{
-    VERIFY_NOT_REACHED();
-}
-
-ErrorOr<void> ProcFSProcessSubDirectoryInode::attach(OpenFileDescription&)
-{
-    return {};
-}
-
-void ProcFSProcessSubDirectoryInode::did_seek(OpenFileDescription&, off_t)
-{
-    VERIFY_NOT_REACHED();
-}
-
-InodeMetadata ProcFSProcessSubDirectoryInode::metadata() const
-{
-    MutexLocker locker(m_inode_lock);
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return {};
-
-    auto traits = process->procfs_traits();
-    InodeMetadata metadata;
-    metadata.inode = { fsid(), traits->component_index() };
-    metadata.mode = S_IFDIR | traits->required_mode();
-    metadata.uid = traits->owner_user();
-    metadata.gid = traits->owner_group();
-    metadata.size = 0;
-    metadata.mtime = traits->modified_time();
-    return metadata;
-}
-
-ErrorOr<void> ProcFSProcessSubDirectoryInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
-{
-    MutexLocker locker(procfs().m_lock);
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return EINVAL;
-    switch (m_sub_directory_type) {
-    case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
-        return process->traverse_file_descriptions_directory(procfs().fsid(), move(callback));
-    case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
-        return process->traverse_stacks_directory(procfs().fsid(), move(callback));
-    case SegmentedProcFSIndex::ProcessSubDirectory::Children:
-        return process->traverse_children_directory(procfs().fsid(), move(callback));
-    default:
-        VERIFY_NOT_REACHED();
-    }
-    VERIFY_NOT_REACHED();
-}
-
-ErrorOr<NonnullLockRefPtr<Inode>> ProcFSProcessSubDirectoryInode::lookup(StringView name)
-{
-    MutexLocker locker(procfs().m_lock);
-    auto process = Process::from_pid_in_same_jail(associated_pid());
-    if (!process)
-        return ESRCH;
-    switch (m_sub_directory_type) {
-    case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
-        return process->lookup_file_descriptions_directory(procfs(), name);
-    case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
-        return process->lookup_stacks_directory(procfs(), name);
-    case SegmentedProcFSIndex::ProcessSubDirectory::Children:
-        return process->lookup_children_directory(procfs(), name);
-    default:
-        VERIFY_NOT_REACHED();
-    }
-}
-
-}
diff --git a/Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.h b/Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.h
deleted file mode 100644
index 4a64281194..0000000000
--- a/Kernel/FileSystem/ProcFS/ProcessSubDirectoryInode.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <Kernel/FileSystem/ProcFS/ProcessAssociatedInode.h>
-#include <Kernel/Forward.h>
-#include <Kernel/ProcessExposed.h>
-
-namespace Kernel {
-
-class ProcFSProcessSubDirectoryInode final : public ProcFSProcessAssociatedInode {
-    friend class ProcFS;
-
-public:
-    static ErrorOr<NonnullLockRefPtr<ProcFSProcessSubDirectoryInode>> try_create(ProcFS const&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
-
-private:
-    ProcFSProcessSubDirectoryInode(ProcFS const&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
-    // ^Inode
-    virtual ErrorOr<void> attach(OpenFileDescription& description) override;
-    virtual void did_seek(OpenFileDescription&, off_t) override;
-    virtual InodeMetadata metadata() const override;
-    virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual ErrorOr<size_t> read_bytes_locked(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> lookup(StringView name) override;
-
-    const SegmentedProcFSIndex::ProcessSubDirectory m_sub_directory_type;
-};
-
-}
diff --git a/Kernel/Forward.h b/Kernel/Forward.h
index 88f53b2fda..1d5f6a303f 100644
--- a/Kernel/Forward.h
+++ b/Kernel/Forward.h
@@ -40,7 +40,6 @@ class MasterPTY;
 class Mount;
 class PerformanceEventBuffer;
 class ProcFS;
-class ProcFSDirectoryInode;
 class ProcFSExposedComponent;
 class ProcFSExposedDirectory;
 class ProcFSInode;
diff --git a/Kernel/Process.h b/Kernel/Process.h
index aaee9f7787..3916e4d257 100644
--- a/Kernel/Process.h
+++ b/Kernel/Process.h
@@ -815,7 +815,7 @@ public:
         }
 
         virtual InodeIndex component_index() const override;
-        virtual ErrorOr<NonnullLockRefPtr<Inode>> to_inode(ProcFS const& procfs_instance) const override;
+        virtual ErrorOr<NonnullLockRefPtr<ProcFSInode>> to_inode(ProcFS const& procfs_instance) const override;
         virtual ErrorOr<void> traverse_as_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
         virtual mode_t required_mode() const override { return 0555; }
 
diff --git a/Kernel/ProcessExposed.cpp b/Kernel/ProcessExposed.cpp
index 7397356681..70e1114a91 100644
--- a/Kernel/ProcessExposed.cpp
+++ b/Kernel/ProcessExposed.cpp
@@ -4,8 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <Kernel/FileSystem/ProcFS/DirectoryInode.h>
-#include <Kernel/FileSystem/ProcFS/LinkInode.h>
+#include <Kernel/FileSystem/ProcFS/Inode.h>
 #include <Kernel/KBufferBuilder.h>
 #include <Kernel/PerformanceEventBuffer.h>
 #include <Kernel/Process.h>
@@ -125,14 +124,14 @@ ErrorOr<size_t> ProcFSExposedLink::read_bytes(off_t offset, size_t count, UserOr
     return nread;
 }
 
-ErrorOr<NonnullLockRefPtr<Inode>> ProcFSExposedLink::to_inode(ProcFS const& procfs_instance) const
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSExposedLink::to_inode(ProcFS const& procfs_instance) const
 {
-    return TRY(ProcFSLinkInode::try_create(procfs_instance, *this));
+    return TRY(ProcFSInode::try_create_as_global_link_inode(procfs_instance, *this));
 }
 
-ErrorOr<NonnullLockRefPtr<Inode>> ProcFSExposedDirectory::to_inode(ProcFS const& procfs_instance) const
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> ProcFSExposedDirectory::to_inode(ProcFS const& procfs_instance) const
 {
-    return TRY(ProcFSDirectoryInode::try_create(procfs_instance, *this));
+    return TRY(ProcFSInode::try_create_as_directory_inode(procfs_instance, *this));
 }
 
 void ProcFSExposedDirectory::add_component(ProcFSExposedComponent const&)
diff --git a/Kernel/ProcessExposed.h b/Kernel/ProcessExposed.h
index bc81a7576a..92d0081ef2 100644
--- a/Kernel/ProcessExposed.h
+++ b/Kernel/ProcessExposed.h
@@ -86,7 +86,7 @@ public:
         return {};
     }
 
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> to_inode(ProcFS const& procfs_instance) const = 0;
+    virtual ErrorOr<NonnullLockRefPtr<ProcFSInode>> to_inode(ProcFS const& procfs_instance) const = 0;
 
     virtual InodeIndex component_index() const { return m_component_index; }
 
@@ -119,7 +119,7 @@ public:
     }
     virtual mode_t required_mode() const override { return 0555; }
 
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> to_inode(ProcFS const& procfs_instance) const override final;
+    virtual ErrorOr<NonnullLockRefPtr<ProcFSInode>> to_inode(ProcFS const& procfs_instance) const override final;
 
 protected:
     explicit ProcFSExposedDirectory(StringView name);
@@ -130,7 +130,7 @@ protected:
 
 class ProcFSExposedLink : public ProcFSExposedComponent {
 public:
-    virtual ErrorOr<NonnullLockRefPtr<Inode>> to_inode(ProcFS const& procfs_instance) const override final;
+    virtual ErrorOr<NonnullLockRefPtr<ProcFSInode>> to_inode(ProcFS const& procfs_instance) const override final;
 
     virtual ErrorOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const override;
 
diff --git a/Kernel/ProcessProcFSTraits.cpp b/Kernel/ProcessProcFSTraits.cpp
index 0686cb9d96..c8688675e9 100644
--- a/Kernel/ProcessProcFSTraits.cpp
+++ b/Kernel/ProcessProcFSTraits.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <Kernel/FileSystem/ProcFS/ProcessDirectoryInode.h>
+#include <Kernel/FileSystem/ProcFS/Inode.h>
 #include <Kernel/Process.h>
 #include <Kernel/ProcessExposed.h>
 
@@ -39,13 +39,13 @@ InodeIndex Process::ProcessProcFSTraits::component_index() const
     return SegmentedProcFSIndex::build_segmented_index_for_pid_directory(process->pid());
 }
 
-ErrorOr<NonnullLockRefPtr<Inode>> Process::ProcessProcFSTraits::to_inode(ProcFS const& procfs_instance) const
+ErrorOr<NonnullLockRefPtr<ProcFSInode>> Process::ProcessProcFSTraits::to_inode(ProcFS const& procfs_instance) const
 {
     auto process = m_process.strong_ref();
     if (!process)
         return ESRCH;
 
-    return TRY(ProcFSProcessDirectoryInode::try_create(procfs_instance, process->pid()));
+    return TRY(ProcFSInode::try_create_as_process_directory_inode(procfs_instance, process->pid()));
 }
 
 ErrorOr<void> Process::ProcessProcFSTraits::traverse_as_directory(FileSystemID fsid, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
diff --git a/Kernel/ProcessSpecificExposed.cpp b/Kernel/ProcessSpecificExposed.cpp
index df86e04943..c5ce04e402 100644
--- a/Kernel/ProcessSpecificExposed.cpp
+++ b/Kernel/ProcessSpecificExposed.cpp
@@ -8,7 +8,7 @@
 #include <AK/JsonObjectSerializer.h>
 #include <AK/JsonValue.h>
 #include <Kernel/FileSystem/Custody.h>
-#include <Kernel/FileSystem/ProcFS/ProcessPropertyInode.h>
+#include <Kernel/FileSystem/ProcFS/Inode.h>
 #include <Kernel/InterruptDisabler.h>
 #include <Kernel/KBufferBuilder.h>
 #include <Kernel/Memory/AnonymousVMObject.h>
@@ -65,12 +65,12 @@ ErrorOr<NonnullLockRefPtr<Inode>> Process::lookup_stacks_directory(ProcFS const&
         return ENOENT;
     auto needle = maybe_needle.release_value();
 
-    ErrorOr<NonnullLockRefPtr<ProcFSProcessPropertyInode>> thread_stack_inode { ENOENT };
+    ErrorOr<NonnullLockRefPtr<ProcFSInode>> thread_stack_inode { ENOENT };
     for_each_thread([&](Thread const& thread) {
         int tid = thread.tid().value();
         VERIFY(!(tid < 0));
         if (needle == (unsigned)tid) {
-            thread_stack_inode = ProcFSProcessPropertyInode::try_create_for_thread_stack(procfs, thread.tid(), pid());
+            thread_stack_inode = ProcFSInode::try_create_as_thread_stack_inode(procfs, thread.tid(), pid());
             return IterationDecision::Break;
         }
         return IterationDecision::Continue;
@@ -105,7 +105,7 @@ ErrorOr<NonnullLockRefPtr<Inode>> Process::lookup_children_directory(ProcFS cons
     if (!child_process || child_process->ppid() != pid())
         return ENOENT;
 
-    return TRY(ProcFSProcessPropertyInode::try_create_for_child_process_link(procfs, *maybe_pid, pid()));
+    return TRY(ProcFSInode::try_create_as_child_process_link_inode(procfs, *maybe_pid, pid()));
 }
 
 ErrorOr<size_t> Process::procfs_get_child_proccess_link(ProcessID child_pid, KBufferBuilder& builder) const
@@ -153,7 +153,7 @@ ErrorOr<NonnullLockRefPtr<Inode>> Process::lookup_file_descriptions_directory(Pr
     if (!m_fds.with_shared([&](auto& fds) { return fds.get_if_valid(*maybe_index); }))
         return ENOENT;
 
-    return TRY(ProcFSProcessPropertyInode::try_create_for_file_description_link(procfs, *maybe_index, pid()));
+    return TRY(ProcFSInode::try_create_as_file_description_link_inode(procfs, *maybe_index, pid()));
 }
 
 ErrorOr<void> Process::procfs_get_pledge_stats(KBufferBuilder& builder) const