Kernel/SysFS: Migrate components code from SysFS.cpp to the SysFS folder

Kernel/FileSystem/SysFS/Subsystems/Devices/BlockDevicesDirectory.cpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/FileSystem/SysFS/Registry.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/BlockDevicesDirectory.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+NonnullRefPtr<SysFSBlockDevicesDirectory> SysFSBlockDevicesDirectory::must_create(SysFSDevicesDirectory const& devices_directory)
+{
+    return adopt_ref_if_nonnull(new SysFSBlockDevicesDirectory(devices_directory)).release_nonnull();
+}
+SysFSBlockDevicesDirectory::SysFSBlockDevicesDirectory(SysFSDevicesDirectory const& devices_directory)
+    : SysFSDirectory(devices_directory)
+{
+}
+
+ErrorOr<void> SysFSBlockDevicesDirectory::traverse_as_directory(FileSystemID fsid, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
+{
+    VERIFY(m_parent_directory);
+    TRY(callback({ ".", { fsid, component_index() }, 0 }));
+    TRY(callback({ "..", { fsid, m_parent_directory->component_index() }, 0 }));
+
+    return SysFSComponentRegistry::the().devices_list().with_exclusive([&](auto& list) -> ErrorOr<void> {
+        for (auto& exposed_device : list) {
+            if (!exposed_device.is_block_device())
+                continue;
+            TRY(callback({ exposed_device.name(), { fsid, exposed_device.component_index() }, 0 }));
+        }
+        return {};
+    });
+}
+
+RefPtr<SysFSComponent> SysFSBlockDevicesDirectory::lookup(StringView name)
+{
+    return SysFSComponentRegistry::the().devices_list().with_exclusive([&](auto& list) -> RefPtr<SysFSComponent> {
+        for (auto& exposed_device : list) {
+            if (!exposed_device.is_block_device())
+                continue;
+            if (exposed_device.name() == name)
+                return exposed_device;
+        }
+        return nullptr;
+    });
+}
+
+}

Kernel/FileSystem/SysFS/Subsystems/Devices/BlockDevicesDirectory.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/FileSystem/SysFS/Component.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/Directory.h>
+
+namespace Kernel {
+
+class SysFSBlockDevicesDirectory final : public SysFSDirectory {
+public:
+    virtual StringView name() const override { return "block"sv; }
+    static NonnullRefPtr<SysFSBlockDevicesDirectory> must_create(SysFSDevicesDirectory const&);
+    virtual ErrorOr<void> traverse_as_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual RefPtr<SysFSComponent> lookup(StringView name) override;
+
+private:
+    explicit SysFSBlockDevicesDirectory(SysFSDevicesDirectory const&);
+};
+
+}

Kernel/FileSystem/SysFS/Subsystems/Devices/CharacterDevicesDirectory.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/FileSystem/SysFS/Registry.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/CharacterDevicesDirectory.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+NonnullRefPtr<SysFSCharacterDevicesDirectory> SysFSCharacterDevicesDirectory::must_create(SysFSDevicesDirectory const& devices_directory)
+{
+    return adopt_ref_if_nonnull(new SysFSCharacterDevicesDirectory(devices_directory)).release_nonnull();
+}
+SysFSCharacterDevicesDirectory::SysFSCharacterDevicesDirectory(SysFSDevicesDirectory const& devices_directory)
+    : SysFSDirectory(devices_directory)
+{
+}
+ErrorOr<void> SysFSCharacterDevicesDirectory::traverse_as_directory(FileSystemID fsid, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
+{
+    VERIFY(m_parent_directory);
+    TRY(callback({ ".", { fsid, component_index() }, 0 }));
+    TRY(callback({ "..", { fsid, m_parent_directory->component_index() }, 0 }));
+
+    return SysFSComponentRegistry::the().devices_list().with_exclusive([&](auto& list) -> ErrorOr<void> {
+        for (auto& exposed_device : list) {
+            if (exposed_device.is_block_device())
+                continue;
+            TRY(callback({ exposed_device.name(), { fsid, exposed_device.component_index() }, 0 }));
+        }
+        return {};
+    });
+}
+
+RefPtr<SysFSComponent> SysFSCharacterDevicesDirectory::lookup(StringView name)
+{
+    return SysFSComponentRegistry::the().devices_list().with_exclusive([&](auto& list) -> RefPtr<SysFSComponent> {
+        for (auto& exposed_device : list) {
+            if (exposed_device.is_block_device())
+                continue;
+            if (exposed_device.name() == name)
+                return exposed_device;
+        }
+        return nullptr;
+    });
+}
+
+}

Kernel/FileSystem/SysFS/Subsystems/Devices/CharacterDevicesDirectory.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/FileSystem/SysFS/Component.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/Directory.h>
+
+namespace Kernel {
+
+class SysFSCharacterDevicesDirectory final : public SysFSDirectory {
+public:
+    virtual StringView name() const override { return "char"sv; }
+    static NonnullRefPtr<SysFSCharacterDevicesDirectory> must_create(SysFSDevicesDirectory const&);
+    virtual ErrorOr<void> traverse_as_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual RefPtr<SysFSComponent> lookup(StringView name) override;
+
+private:
+    explicit SysFSCharacterDevicesDirectory(SysFSDevicesDirectory const&);
+};
+
+}

Kernel/FileSystem/SysFS/Subsystems/Devices/DeviceComponent.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Devices/Device.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/DeviceComponent.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+NonnullRefPtr<SysFSDeviceComponent> SysFSDeviceComponent::must_create(Device const& device)
+{
+    // FIXME: Handle allocation failure gracefully
+    auto device_name = MUST(KString::formatted("{}:{}", device.major(), device.minor()));
+    return adopt_ref_if_nonnull(new SysFSDeviceComponent(move(device_name), device)).release_nonnull();
+}
+SysFSDeviceComponent::SysFSDeviceComponent(NonnullOwnPtr<KString> major_minor_formatted_device_name, Device const& device)
+    : SysFSComponent()
+    , m_block_device(device.is_block_device())
+    , m_major_minor_formatted_device_name(move(major_minor_formatted_device_name))
+{
+    VERIFY(device.is_block_device() || device.is_character_device());
+}
+
+}

Kernel/FileSystem/SysFS/Subsystems/Devices/DeviceComponent.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/IntrusiveList.h>
+#include <Kernel/FileSystem/SysFS/Component.h>
+#include <Kernel/KString.h>
+
+namespace Kernel {
+
+class SysFSDeviceComponent final
+    : public SysFSComponent
+    , public Weakable<SysFSDeviceComponent> {
+    friend class SysFSComponentRegistry;
+
+public:
+    static NonnullRefPtr<SysFSDeviceComponent> must_create(Device const&);
+    virtual StringView name() const override { return m_major_minor_formatted_device_name->view(); }
+    bool is_block_device() const { return m_block_device; }
+
+private:
+    SysFSDeviceComponent(NonnullOwnPtr<KString> major_minor_formatted_device_name, Device const&);
+    IntrusiveListNode<SysFSDeviceComponent, NonnullRefPtr<SysFSDeviceComponent>> m_list_node;
+    bool m_block_device;
+
+    NonnullOwnPtr<KString> m_major_minor_formatted_device_name;
+};
+
+}

Kernel/FileSystem/SysFS/Subsystems/Devices/Directory.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/FileSystem/SysFS/RootDirectory.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/BlockDevicesDirectory.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/CharacterDevicesDirectory.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Devices/Directory.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullRefPtr<SysFSDevicesDirectory> SysFSDevicesDirectory::must_create(SysFSRootDirectory const& root_directory)
+{
+    auto devices_directory = adopt_ref_if_nonnull(new SysFSDevicesDirectory(root_directory)).release_nonnull();
+    devices_directory->m_components.append(SysFSBlockDevicesDirectory::must_create(*devices_directory));
+    devices_directory->m_components.append(SysFSCharacterDevicesDirectory::must_create(*devices_directory));
+    return devices_directory;
+}
+SysFSDevicesDirectory::SysFSDevicesDirectory(SysFSRootDirectory const& root_directory)
+    : SysFSDirectory(root_directory)
+{
+}
+
+}

Kernel/FileSystem/SysFS/Subsystems/Devices/Directory.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/FileSystem/SysFS/Component.h>
+#include <Kernel/Forward.h>
+
+namespace Kernel {
+
+class SysFSDevicesDirectory final : public SysFSDirectory {
+public:
+    virtual StringView name() const override { return "dev"sv; }
+    static NonnullRefPtr<SysFSDevicesDirectory> must_create(SysFSRootDirectory const&);
+
+private:
+    explicit SysFSDevicesDirectory(SysFSRootDirectory const&);
+};
+
+}