Kernel/SysFS: Stop cluttering the codebase with pieces of SysFS parts

Instead, start to put everything in one place to resemble the directory
structure of the SysFS when actually using it.

Kernel/FileSystem/SysFS.h

@@ -8,7 +8,7 @@
 
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/Inode.h>
-#include <Kernel/FileSystem/SysFSComponent.h>
+#include <Kernel/FileSystem/SysFS/Component.h>
 #include <Kernel/Locking/MutexProtected.h>
 
 namespace Kernel {

Kernel/FileSystem/SysFS/Component.cpp

@@ -5,7 +5,7 @@
  */
 
 #include <Kernel/FileSystem/SysFS.h>
-#include <Kernel/FileSystem/SysFSComponent.h>
+#include <Kernel/FileSystem/SysFS/Component.h>
 
 namespace Kernel {
 

Kernel/FileSystem/SysFS/Subsystems/Bus/PCI/SysFSPCI.cpp

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Bus/PCI/API.h>
+#include <Kernel/Bus/PCI/Access.h>
+#include <Kernel/Debug.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Bus/PCI/SysFSPCI.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel::PCI {
+
+UNMAP_AFTER_INIT NonnullRefPtr<PCIDeviceSysFSDirectory> PCIDeviceSysFSDirectory::create(SysFSDirectory const& parent_directory, Address address)
+{
+    // FIXME: Handle allocation failure gracefully
+    auto device_name = MUST(KString::formatted("{:04x}:{:02x}:{:02x}.{}", address.domain(), address.bus(), address.device(), address.function()));
+    return adopt_ref(*new (nothrow) PCIDeviceSysFSDirectory(move(device_name), parent_directory, address));
+}
+
+UNMAP_AFTER_INIT PCIDeviceSysFSDirectory::PCIDeviceSysFSDirectory(NonnullOwnPtr<KString> device_directory_name, SysFSDirectory const& parent_directory, Address address)
+    : SysFSDirectory(parent_directory)
+    , m_address(address)
+    , m_device_directory_name(move(device_directory_name))
+{
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::VENDOR_ID, 2));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::DEVICE_ID, 2));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::CLASS, 1));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::SUBCLASS, 1));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::REVISION_ID, 1));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::PROG_IF, 1));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::SUBSYSTEM_VENDOR_ID, 2));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::SUBSYSTEM_ID, 2));
+
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::BAR0, 4));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::BAR1, 4));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::BAR2, 4));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::BAR3, 4));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::BAR4, 4));
+    m_components.append(PCIDeviceAttributeSysFSComponent::create(*this, PCI::RegisterOffset::BAR5, 4));
+}
+
+UNMAP_AFTER_INIT void PCIBusSysFSDirectory::initialize()
+{
+    auto pci_directory = adopt_ref(*new (nothrow) PCIBusSysFSDirectory());
+    SysFSComponentRegistry::the().register_new_bus_directory(pci_directory);
+}
+
+UNMAP_AFTER_INIT PCIBusSysFSDirectory::PCIBusSysFSDirectory()
+    : SysFSDirectory(SysFSComponentRegistry::the().buses_directory())
+{
+    MUST(PCI::enumerate([&](DeviceIdentifier const& device_identifier) {
+        auto pci_device = PCI::PCIDeviceSysFSDirectory::create(*this, device_identifier.address());
+        m_components.append(pci_device);
+    }));
+}
+
+StringView PCIDeviceAttributeSysFSComponent::name() const
+{
+    switch (m_offset) {
+    case PCI::RegisterOffset::VENDOR_ID:
+        return "vendor"sv;
+    case PCI::RegisterOffset::DEVICE_ID:
+        return "device_id"sv;
+    case PCI::RegisterOffset::CLASS:
+        return "class"sv;
+    case PCI::RegisterOffset::SUBCLASS:
+        return "subclass"sv;
+    case PCI::RegisterOffset::REVISION_ID:
+        return "revision"sv;
+    case PCI::RegisterOffset::PROG_IF:
+        return "progif"sv;
+    case PCI::RegisterOffset::SUBSYSTEM_VENDOR_ID:
+        return "subsystem_vendor"sv;
+    case PCI::RegisterOffset::SUBSYSTEM_ID:
+        return "subsystem_id"sv;
+    case PCI::RegisterOffset::BAR0:
+        return "bar0"sv;
+    case PCI::RegisterOffset::BAR1:
+        return "bar1"sv;
+    case PCI::RegisterOffset::BAR2:
+        return "bar2"sv;
+    case PCI::RegisterOffset::BAR3:
+        return "bar3"sv;
+    case PCI::RegisterOffset::BAR4:
+        return "bar4"sv;
+    case PCI::RegisterOffset::BAR5:
+        return "bar5"sv;
+    default:
+        VERIFY_NOT_REACHED();
+    }
+}
+
+NonnullRefPtr<PCIDeviceAttributeSysFSComponent> PCIDeviceAttributeSysFSComponent::create(PCIDeviceSysFSDirectory const& device, PCI::RegisterOffset offset, size_t field_bytes_width)
+{
+    return adopt_ref(*new (nothrow) PCIDeviceAttributeSysFSComponent(device, offset, field_bytes_width));
+}
+
+PCIDeviceAttributeSysFSComponent::PCIDeviceAttributeSysFSComponent(PCIDeviceSysFSDirectory const& device, PCI::RegisterOffset offset, size_t field_bytes_width)
+    : SysFSComponent()
+    , m_device(device)
+    , m_offset(offset)
+    , m_field_bytes_width(field_bytes_width)
+{
+}
+
+ErrorOr<size_t> PCIDeviceAttributeSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+{
+    auto blob = TRY(try_to_generate_buffer());
+
+    if ((size_t)offset >= blob->size())
+        return 0;
+
+    ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
+    TRY(buffer.write(blob->data() + offset, nread));
+    return nread;
+}
+
+ErrorOr<NonnullOwnPtr<KBuffer>> PCIDeviceAttributeSysFSComponent::try_to_generate_buffer() const
+{
+    OwnPtr<KString> value;
+    switch (m_field_bytes_width) {
+    case 1:
+        value = TRY(KString::formatted("{:#x}", PCI::read8(m_device->address(), m_offset)));
+        break;
+    case 2:
+        value = TRY(KString::formatted("{:#x}", PCI::read16(m_device->address(), m_offset)));
+        break;
+    case 4:
+        value = TRY(KString::formatted("{:#x}", PCI::read32(m_device->address(), m_offset)));
+        break;
+    default:
+        VERIFY_NOT_REACHED();
+    }
+
+    return KBuffer::try_create_with_bytes(value->view().bytes());
+}
+}

Kernel/FileSystem/SysFS/Subsystems/Bus/PCI/SysFSPCI.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Vector.h>
+#include <Kernel/Bus/PCI/Definitions.h>
+#include <Kernel/FileSystem/SysFS.h>
+
+namespace Kernel::PCI {
+
+class PCIBusSysFSDirectory final : public SysFSDirectory {
+public:
+    static void initialize();
+    virtual StringView name() const override { return "pci"sv; }
+
+private:
+    PCIBusSysFSDirectory();
+};
+
+class PCIDeviceSysFSDirectory final : public SysFSDirectory {
+public:
+    static NonnullRefPtr<PCIDeviceSysFSDirectory> create(SysFSDirectory const&, Address);
+    Address const& address() const { return m_address; }
+
+    virtual StringView name() const override { return m_device_directory_name->view(); }
+
+private:
+    PCIDeviceSysFSDirectory(NonnullOwnPtr<KString> device_directory_name, SysFSDirectory const&, Address);
+
+    Address m_address;
+
+    NonnullOwnPtr<KString> m_device_directory_name;
+};
+
+class PCIDeviceAttributeSysFSComponent : public SysFSComponent {
+public:
+    static NonnullRefPtr<PCIDeviceAttributeSysFSComponent> create(PCIDeviceSysFSDirectory const& device, PCI::RegisterOffset offset, size_t field_bytes_width);
+
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
+    virtual ~PCIDeviceAttributeSysFSComponent() {};
+
+    virtual StringView name() const override;
+
+protected:
+    ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const;
+    PCIDeviceAttributeSysFSComponent(PCIDeviceSysFSDirectory const& device, PCI::RegisterOffset offset, size_t field_bytes_width);
+    NonnullRefPtr<PCIDeviceSysFSDirectory> m_device;
+    PCI::RegisterOffset m_offset;
+    size_t m_field_bytes_width;
+};
+
+}

Kernel/FileSystem/SysFS/Subsystems/Bus/USB/SysFSUSB.cpp

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ * Copyright (c) 2022, Jesse Buhagiar <jesse.buhagiar@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/JsonArraySerializer.h>
+#include <AK/JsonObjectSerializer.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Bus/USB/SysFSUSB.h>
+#include <Kernel/KBufferBuilder.h>
+
+namespace Kernel::USB {
+
+static SysFSUSBBusDirectory* s_procfs_usb_bus_directory;
+
+SysFSUSBDeviceInformation::SysFSUSBDeviceInformation(NonnullOwnPtr<KString> device_name, USB::Device& device)
+    : SysFSComponent()
+    , m_device(device)
+    , m_device_name(move(device_name))
+{
+}
+
+SysFSUSBDeviceInformation::~SysFSUSBDeviceInformation() = default;
+
+ErrorOr<void> SysFSUSBDeviceInformation::try_generate(KBufferBuilder& builder)
+{
+    VERIFY(m_lock.is_locked());
+    auto array = TRY(JsonArraySerializer<>::try_create(builder));
+
+    auto obj = TRY(array.add_object());
+    TRY(obj.add("device_address", m_device->address()));
+    TRY(obj.add("usb_spec_compliance_bcd", m_device->device_descriptor().usb_spec_compliance_bcd));
+    TRY(obj.add("device_class", m_device->device_descriptor().device_class));
+    TRY(obj.add("device_sub_class", m_device->device_descriptor().device_sub_class));
+    TRY(obj.add("device_protocol", m_device->device_descriptor().device_protocol));
+    TRY(obj.add("max_packet_size", m_device->device_descriptor().max_packet_size));
+    TRY(obj.add("vendor_id", m_device->device_descriptor().vendor_id));
+    TRY(obj.add("product_id", m_device->device_descriptor().product_id));
+    TRY(obj.add("device_release_bcd", m_device->device_descriptor().device_release_bcd));
+    TRY(obj.add("manufacturer_id_descriptor_index", m_device->device_descriptor().manufacturer_id_descriptor_index));
+    TRY(obj.add("product_string_descriptor_index", m_device->device_descriptor().product_string_descriptor_index));
+    TRY(obj.add("serial_number_descriptor_index", m_device->device_descriptor().serial_number_descriptor_index));
+    TRY(obj.add("num_configurations", m_device->device_descriptor().num_configurations));
+    TRY(obj.add("length", m_device->device_descriptor().descriptor_header.length));
+    TRY(obj.add("descriptor_type", m_device->device_descriptor().descriptor_header.descriptor_type));
+
+    auto configuration_array = TRY(obj.add_array("configurations"));
+    for (auto const& configuration : m_device->configurations()) {
+        auto configuration_object = TRY(configuration_array.add_object());
+        auto const& configuration_descriptor = configuration.descriptor();
+        TRY(configuration_object.add("length", configuration_descriptor.descriptor_header.length));
+        TRY(configuration_object.add("descriptor_type", configuration_descriptor.descriptor_header.descriptor_type));
+        TRY(configuration_object.add("total_length", configuration_descriptor.total_length));
+        TRY(configuration_object.add("number_of_interfaces", configuration_descriptor.number_of_interfaces));
+        TRY(configuration_object.add("attributes_bitmap", configuration_descriptor.attributes_bitmap));
+        TRY(configuration_object.add("max_power", configuration_descriptor.max_power_in_ma));
+
+        auto interface_array = TRY(configuration_object.add_array("interfaces"));
+        for (auto const& interface : configuration.interfaces()) {
+            auto interface_object = TRY(interface_array.add_object());
+            auto const& interface_descriptor = interface.descriptor();
+            TRY(interface_object.add("length", interface_descriptor.descriptor_header.length));
+            TRY(interface_object.add("descriptor_type", interface_descriptor.descriptor_header.descriptor_type));
+            TRY(interface_object.add("interface_number", interface_descriptor.interface_id));
+            TRY(interface_object.add("alternate_setting", interface_descriptor.alternate_setting));
+            TRY(interface_object.add("num_endpoints", interface_descriptor.number_of_endpoints));
+            TRY(interface_object.add("interface_class_code", interface_descriptor.interface_class_code));
+            TRY(interface_object.add("interface_sub_class_code", interface_descriptor.interface_sub_class_code));
+            TRY(interface_object.add("interface_protocol", interface_descriptor.interface_protocol));
+            TRY(interface_object.add("interface_string_desc_index", interface_descriptor.interface_string_descriptor_index));
+
+            auto endpoint_array = TRY(interface_object.add_array("endpoints"));
+            for (auto const& endpoint : interface.endpoints()) {
+                auto endpoint_object = TRY(endpoint_array.add_object());
+                TRY(endpoint_object.add("length", endpoint.descriptor_header.length));
+                TRY(endpoint_object.add("descriptor_length", endpoint.descriptor_header.descriptor_type));
+                TRY(endpoint_object.add("endpoint_address", endpoint.endpoint_address));
+                TRY(endpoint_object.add("attribute_bitmap", endpoint.endpoint_attributes_bitmap));
+                TRY(endpoint_object.add("max_packet_size", endpoint.max_packet_size));
+                TRY(endpoint_object.add("polling_interval", endpoint.poll_interval_in_frames));
+                TRY(endpoint_object.finish());
+            }
+            TRY(endpoint_array.finish());
+            TRY(interface_object.finish());
+        }
+        TRY(interface_array.finish());
+        TRY(configuration_object.finish());
+    }
+    TRY(configuration_array.finish());
+
+    TRY(obj.finish());
+    TRY(array.finish());
+    return {};
+}
+
+ErrorOr<void> SysFSUSBDeviceInformation::refresh_data(OpenFileDescription& description) const
+{
+    MutexLocker lock(m_lock);
+    auto& cached_data = description.data();
+    if (!cached_data) {
+        cached_data = TRY(adopt_nonnull_own_or_enomem(new (nothrow) SysFSInodeData));
+    }
+    auto builder = TRY(KBufferBuilder::try_create());
+    TRY(const_cast<SysFSUSBDeviceInformation&>(*this).try_generate(builder));
+    auto& typed_cached_data = static_cast<SysFSInodeData&>(*cached_data);
+    typed_cached_data.buffer = builder.build();
+    if (!typed_cached_data.buffer)
+        return ENOMEM;
+    return {};
+}
+
+ErrorOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
+{
+    dbgln_if(PROCFS_DEBUG, "SysFSUSBDeviceInformation @ {}: read_bytes offset: {} count: {}", name(), offset, count);
+
+    VERIFY(offset >= 0);
+    VERIFY(buffer.user_or_kernel_ptr());
+
+    if (!description)
+        return Error::from_errno(EIO);
+
+    MutexLocker locker(m_lock);
+
+    if (!description->data()) {
+        dbgln("SysFSUSBDeviceInformation: Do not have cached data!");
+        return Error::from_errno(EIO);
+    }
+
+    auto& typed_cached_data = static_cast<SysFSInodeData&>(*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<void> SysFSUSBBusDirectory::traverse_as_directory(FileSystemID fsid, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
+{
+    SpinlockLocker lock(m_lock);
+    // Note: if the parent directory is null, it means something bad happened as this should not happen for the USB directory.
+    VERIFY(m_parent_directory);
+    TRY(callback({ ".", { fsid, component_index() }, 0 }));
+    TRY(callback({ "..", { fsid, m_parent_directory->component_index() }, 0 }));
+
+    for (auto const& device_node : m_device_nodes) {
+        InodeIdentifier identifier = { fsid, device_node.component_index() };
+        TRY(callback({ device_node.name(), identifier, 0 }));
+    }
+    return {};
+}
+
+RefPtr<SysFSComponent> SysFSUSBBusDirectory::lookup(StringView name)
+{
+    SpinlockLocker lock(m_lock);
+    for (auto& device_node : m_device_nodes) {
+        if (device_node.name() == name) {
+            return device_node;
+        }
+    }
+    return {};
+}
+
+RefPtr<SysFSUSBDeviceInformation> SysFSUSBBusDirectory::device_node_for(USB::Device& device)
+{
+    RefPtr<USB::Device> checked_device = device;
+    for (auto& device_node : m_device_nodes) {
+        if (device_node.device().ptr() == checked_device.ptr())
+            return device_node;
+    }
+    return {};
+}
+
+void SysFSUSBBusDirectory::plug(USB::Device& new_device)
+{
+    SpinlockLocker lock(m_lock);
+    auto device_node = device_node_for(new_device);
+    VERIFY(!device_node);
+    auto sysfs_usb_device_or_error = SysFSUSBDeviceInformation::create(new_device);
+    if (sysfs_usb_device_or_error.is_error()) {
+        dbgln("Failed to create SysFSUSBDevice for device id {}", new_device.address());
+        return;
+    }
+
+    m_device_nodes.append(sysfs_usb_device_or_error.release_value());
+}
+
+void SysFSUSBBusDirectory::unplug(USB::Device& deleted_device)
+{
+    SpinlockLocker lock(m_lock);
+    auto device_node = device_node_for(deleted_device);
+    VERIFY(device_node);
+    device_node->m_list_node.remove();
+}
+
+SysFSUSBBusDirectory& SysFSUSBBusDirectory::the()
+{
+    VERIFY(s_procfs_usb_bus_directory);
+    return *s_procfs_usb_bus_directory;
+}
+
+UNMAP_AFTER_INIT SysFSUSBBusDirectory::SysFSUSBBusDirectory(SysFSBusDirectory& buses_directory)
+    : SysFSDirectory(buses_directory)
+{
+}
+
+UNMAP_AFTER_INIT void SysFSUSBBusDirectory::initialize()
+{
+    auto directory = adopt_ref(*new SysFSUSBBusDirectory(SysFSComponentRegistry::the().buses_directory()));
+    SysFSComponentRegistry::the().register_new_bus_directory(directory);
+    s_procfs_usb_bus_directory = directory;
+}
+
+ErrorOr<NonnullRefPtr<SysFSUSBDeviceInformation>> SysFSUSBDeviceInformation::create(USB::Device& device)
+{
+    auto device_name = TRY(KString::number(device.address()));
+    return adopt_nonnull_ref_or_enomem(new (nothrow) SysFSUSBDeviceInformation(move(device_name), device));
+}
+
+}

Kernel/FileSystem/SysFS/Subsystems/Bus/USB/SysFSUSB.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/Bus/USB/USBDevice.h>
+#include <Kernel/FileSystem/SysFS.h>
+#include <Kernel/KBufferBuilder.h>
+#include <Kernel/Locking/Mutex.h>
+
+namespace Kernel::USB {
+
+class SysFSUSBDeviceInformation : public SysFSComponent {
+    friend class SysFSUSBBusDirectory;
+
+public:
+    virtual ~SysFSUSBDeviceInformation() override;
+
+    static ErrorOr<NonnullRefPtr<SysFSUSBDeviceInformation>> create(USB::Device&);
+    virtual StringView name() const override { return m_device_name->view(); }
+
+    RefPtr<USB::Device> device() const { return m_device; }
+
+protected:
+    SysFSUSBDeviceInformation(NonnullOwnPtr<KString> device_name, USB::Device& device);
+
+    virtual ErrorOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+
+    IntrusiveListNode<SysFSUSBDeviceInformation, RefPtr<SysFSUSBDeviceInformation>> m_list_node;
+
+    NonnullRefPtr<USB::Device> m_device;
+
+private:
+    ErrorOr<void> try_generate(KBufferBuilder&);
+    virtual ErrorOr<void> refresh_data(OpenFileDescription& description) const override;
+    mutable Mutex m_lock { "SysFSUSBDeviceInformation" };
+    NonnullOwnPtr<KString> m_device_name;
+};
+
+class SysFSUSBBusDirectory final : public SysFSDirectory {
+public:
+    static void initialize();
+    static SysFSUSBBusDirectory& the();
+
+    virtual StringView name() const override { return "usb"sv; }
+
+    void plug(USB::Device&);
+    void unplug(USB::Device&);
+
+    virtual ErrorOr<void> traverse_as_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual RefPtr<SysFSComponent> lookup(StringView name) override;
+
+private:
+    explicit SysFSUSBBusDirectory(SysFSBusDirectory&);
+
+    RefPtr<SysFSUSBDeviceInformation> device_node_for(USB::Device& device);
+
+    IntrusiveList<&SysFSUSBDeviceInformation::m_list_node> m_device_nodes;
+    mutable Spinlock m_lock;
+};
+
+}

Kernel/FileSystem/SysFS/Subsystems/Firmware/BIOS.cpp

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/StringView.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/BIOS.h>
+#include <Kernel/KBufferBuilder.h>
+#include <Kernel/Memory/MemoryManager.h>
+#include <Kernel/Memory/TypedMapping.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+#define SMBIOS_BASE_SEARCH_ADDR 0xf0000
+#define SMBIOS_END_SEARCH_ADDR 0xfffff
+#define SMBIOS_SEARCH_AREA_SIZE (SMBIOS_END_SEARCH_ADDR - SMBIOS_BASE_SEARCH_ADDR)
+
+UNMAP_AFTER_INIT NonnullRefPtr<DMIEntryPointExposedBlob> DMIEntryPointExposedBlob::must_create(PhysicalAddress dmi_entry_point, size_t blob_size)
+{
+    return adopt_ref(*new (nothrow) DMIEntryPointExposedBlob(dmi_entry_point, blob_size));
+}
+
+UNMAP_AFTER_INIT BIOSSysFSComponent::BIOSSysFSComponent()
+{
+}
+
+ErrorOr<size_t> BIOSSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+{
+    auto blob = TRY(try_to_generate_buffer());
+
+    if ((size_t)offset >= blob->size())
+        return 0;
+
+    ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
+    TRY(buffer.write(blob->data() + offset, nread));
+    return nread;
+}
+
+UNMAP_AFTER_INIT DMIEntryPointExposedBlob::DMIEntryPointExposedBlob(PhysicalAddress dmi_entry_point, size_t blob_size)
+    : BIOSSysFSComponent()
+    , m_dmi_entry_point(dmi_entry_point)
+    , m_dmi_entry_point_length(blob_size)
+{
+}
+
+ErrorOr<NonnullOwnPtr<KBuffer>> DMIEntryPointExposedBlob::try_to_generate_buffer() const
+{
+    auto dmi_blob = TRY(Memory::map_typed<u8>((m_dmi_entry_point), m_dmi_entry_point_length));
+    return KBuffer::try_create_with_bytes(Span<u8> { dmi_blob.ptr(), m_dmi_entry_point_length });
+}
+
+UNMAP_AFTER_INIT NonnullRefPtr<SMBIOSExposedTable> SMBIOSExposedTable::must_create(PhysicalAddress smbios_structure_table, size_t smbios_structure_table_length)
+{
+    return adopt_ref(*new (nothrow) SMBIOSExposedTable(smbios_structure_table, smbios_structure_table_length));
+}
+
+UNMAP_AFTER_INIT SMBIOSExposedTable::SMBIOSExposedTable(PhysicalAddress smbios_structure_table, size_t smbios_structure_table_length)
+    : BIOSSysFSComponent()
+    , m_smbios_structure_table(smbios_structure_table)
+    , m_smbios_structure_table_length(smbios_structure_table_length)
+{
+}
+
+ErrorOr<NonnullOwnPtr<KBuffer>> SMBIOSExposedTable::try_to_generate_buffer() const
+{
+    auto dmi_blob = TRY(Memory::map_typed<u8>((m_smbios_structure_table), m_smbios_structure_table_length));
+    return KBuffer::try_create_with_bytes(Span<u8> { dmi_blob.ptr(), m_smbios_structure_table_length });
+}
+
+UNMAP_AFTER_INIT void BIOSSysFSDirectory::set_dmi_64_bit_entry_initialization_values()
+{
+    dbgln("BIOSSysFSDirectory: SMBIOS 64bit Entry point @ {}", m_dmi_entry_point);
+    auto smbios_entry = Memory::map_typed<SMBIOS::EntryPoint64bit>(m_dmi_entry_point, SMBIOS_SEARCH_AREA_SIZE).release_value_but_fixme_should_propagate_errors();
+    m_smbios_structure_table = PhysicalAddress(smbios_entry.ptr()->table_ptr);
+    m_dmi_entry_point_length = smbios_entry.ptr()->length;
+    m_smbios_structure_table_length = smbios_entry.ptr()->table_maximum_size;
+}
+
+UNMAP_AFTER_INIT void BIOSSysFSDirectory::set_dmi_32_bit_entry_initialization_values()
+{
+    dbgln("BIOSSysFSDirectory: SMBIOS 32bit Entry point @ {}", m_dmi_entry_point);
+    auto smbios_entry = Memory::map_typed<SMBIOS::EntryPoint32bit>(m_dmi_entry_point, SMBIOS_SEARCH_AREA_SIZE).release_value_but_fixme_should_propagate_errors();
+    m_smbios_structure_table = PhysicalAddress(smbios_entry.ptr()->legacy_structure.smbios_table_ptr);
+    m_dmi_entry_point_length = smbios_entry.ptr()->length;
+    m_smbios_structure_table_length = smbios_entry.ptr()->legacy_structure.smbios_table_length;
+}
+
+UNMAP_AFTER_INIT NonnullRefPtr<BIOSSysFSDirectory> BIOSSysFSDirectory::must_create(FirmwareSysFSDirectory& firmware_directory)
+{
+    auto bios_directory = MUST(adopt_nonnull_ref_or_enomem(new (nothrow) BIOSSysFSDirectory(firmware_directory)));
+    bios_directory->create_components();
+    return bios_directory;
+}
+
+void BIOSSysFSDirectory::create_components()
+{
+    if (m_dmi_entry_point.is_null() || m_smbios_structure_table.is_null())
+        return;
+    if (m_dmi_entry_point_length == 0) {
+        dbgln("BIOSSysFSDirectory: invalid dmi entry length");
+        return;
+    }
+    if (m_smbios_structure_table_length == 0) {
+        dbgln("BIOSSysFSDirectory: invalid smbios structure table length");
+        return;
+    }
+    m_components.append(DMIEntryPointExposedBlob::must_create(m_dmi_entry_point, m_dmi_entry_point_length));
+    m_components.append(SMBIOSExposedTable::must_create(m_smbios_structure_table, m_smbios_structure_table_length));
+}
+
+UNMAP_AFTER_INIT void BIOSSysFSDirectory::initialize_dmi_exposer()
+{
+    VERIFY(!(m_dmi_entry_point.is_null()));
+    if (m_using_64bit_dmi_entry_point) {
+        set_dmi_64_bit_entry_initialization_values();
+    } else {
+        set_dmi_32_bit_entry_initialization_values();
+    }
+    dbgln("BIOSSysFSDirectory: Data table @ {}", m_smbios_structure_table);
+}
+
+UNMAP_AFTER_INIT BIOSSysFSDirectory::BIOSSysFSDirectory(FirmwareSysFSDirectory& firmware_directory)
+    : SysFSDirectory(firmware_directory)
+{
+    auto entry_32bit = find_dmi_entry32bit_point();
+    if (entry_32bit.has_value()) {
+        m_dmi_entry_point = entry_32bit.value();
+    }
+
+    auto entry_64bit = find_dmi_entry64bit_point();
+    if (entry_64bit.has_value()) {
+        m_dmi_entry_point = entry_64bit.value();
+        m_using_64bit_dmi_entry_point = true;
+    }
+    if (m_dmi_entry_point.is_null())
+        return;
+    initialize_dmi_exposer();
+}
+
+UNMAP_AFTER_INIT Optional<PhysicalAddress> BIOSSysFSDirectory::find_dmi_entry64bit_point()
+{
+    auto bios_or_error = map_bios();
+    if (bios_or_error.is_error())
+        return {};
+    return bios_or_error.value().find_chunk_starting_with("_SM3_", 16);
+}
+
+UNMAP_AFTER_INIT Optional<PhysicalAddress> BIOSSysFSDirectory::find_dmi_entry32bit_point()
+{
+    auto bios_or_error = map_bios();
+    if (bios_or_error.is_error())
+        return {};
+    return bios_or_error.value().find_chunk_starting_with("_SM_", 16);
+}
+
+ErrorOr<Memory::MappedROM> map_bios()
+{
+    Memory::MappedROM mapping;
+    mapping.size = 128 * KiB;
+    mapping.paddr = PhysicalAddress(0xe0000);
+    auto region_size = TRY(Memory::page_round_up(mapping.size));
+    mapping.region = TRY(MM.allocate_kernel_region(mapping.paddr, region_size, {}, Memory::Region::Access::Read));
+    return mapping;
+}
+
+ErrorOr<Memory::MappedROM> map_ebda()
+{
+    auto ebda_segment_ptr = TRY(Memory::map_typed<u16>(PhysicalAddress(0x40e)));
+    PhysicalAddress ebda_paddr(PhysicalAddress(*ebda_segment_ptr).get() << 4);
+    // The EBDA size is stored in the first byte of the EBDA in 1K units
+    size_t ebda_size = *TRY(Memory::map_typed<u8>(ebda_paddr));
+    ebda_size *= 1024;
+
+    Memory::MappedROM mapping;
+    auto region_size = TRY(Memory::page_round_up(ebda_size));
+    mapping.region = TRY(MM.allocate_kernel_region(ebda_paddr.page_base(), region_size, {}, Memory::Region::Access::Read));
+    mapping.offset = ebda_paddr.offset_in_page();
+    mapping.size = ebda_size;
+    mapping.paddr = ebda_paddr;
+    return mapping;
+}
+
+}

Kernel/FileSystem/SysFS/Subsystems/Firmware/BIOS.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/RefPtr.h>
+#include <AK/Types.h>
+#include <AK/Vector.h>
+#include <Kernel/FileSystem/SysFS.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/Directory.h>
+#include <Kernel/KBuffer.h>
+#include <Kernel/Memory/MappedROM.h>
+#include <Kernel/Memory/Region.h>
+#include <Kernel/PhysicalAddress.h>
+#include <Kernel/VirtualAddress.h>
+
+namespace Kernel::SMBIOS {
+
+struct [[gnu::packed]] LegacyEntryPoint32bit {
+    char legacy_sig[5];
+    u8 checksum2;
+    u16 smbios_table_length;
+    u32 smbios_table_ptr;
+    u16 smbios_tables_count;
+    u8 smbios_bcd_revision;
+};
+
+struct [[gnu::packed]] EntryPoint32bit {
+    char sig[4];
+    u8 checksum;
+    u8 length;
+    u8 major_version;
+    u8 minor_version;
+    u16 maximum_structure_size;
+    u8 implementation_revision;
+    char formatted_area[5];
+    LegacyEntryPoint32bit legacy_structure;
+};
+
+struct [[gnu::packed]] EntryPoint64bit {
+    char sig[5];
+    u8 checksum;
+    u8 length;
+    u8 major_version;
+    u8 minor_version;
+    u8 document_revision;
+    u8 revision;
+    u8 reserved;
+    u32 table_maximum_size;
+    u64 table_ptr;
+};
+}
+
+namespace Kernel {
+
+ErrorOr<Memory::MappedROM> map_bios();
+ErrorOr<Memory::MappedROM> map_ebda();
+
+class BIOSSysFSComponent : public SysFSComponent {
+public:
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
+
+protected:
+    virtual ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const = 0;
+    BIOSSysFSComponent();
+};
+
+class DMIEntryPointExposedBlob final : public BIOSSysFSComponent {
+public:
+    virtual StringView name() const override { return "smbios_entry_point"sv; }
+    static NonnullRefPtr<DMIEntryPointExposedBlob> must_create(PhysicalAddress dmi_entry_point, size_t blob_size);
+
+private:
+    DMIEntryPointExposedBlob(PhysicalAddress dmi_entry_point, size_t blob_size);
+    virtual ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const override;
+
+    virtual size_t size() const override { return m_dmi_entry_point_length; }
+
+    PhysicalAddress m_dmi_entry_point;
+    size_t const m_dmi_entry_point_length { 0 };
+};
+
+class SMBIOSExposedTable final : public BIOSSysFSComponent {
+public:
+    virtual StringView name() const override { return "DMI"sv; }
+    static NonnullRefPtr<SMBIOSExposedTable> must_create(PhysicalAddress, size_t blob_size);
+
+private:
+    SMBIOSExposedTable(PhysicalAddress dmi_entry_point, size_t blob_size);
+    virtual ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const override;
+
+    virtual size_t size() const override { return m_smbios_structure_table_length; }
+
+    PhysicalAddress m_smbios_structure_table;
+    size_t const m_smbios_structure_table_length { 0 };
+};
+
+class BIOSSysFSDirectory : public SysFSDirectory {
+public:
+    virtual StringView name() const override { return "bios"sv; }
+    static NonnullRefPtr<BIOSSysFSDirectory> must_create(FirmwareSysFSDirectory&);
+
+    void create_components();
+
+private:
+    explicit BIOSSysFSDirectory(FirmwareSysFSDirectory&);
+
+    void set_dmi_64_bit_entry_initialization_values();
+    void set_dmi_32_bit_entry_initialization_values();
+    void initialize_dmi_exposer();
+
+    Optional<PhysicalAddress> find_dmi_entry64bit_point();
+    Optional<PhysicalAddress> find_dmi_entry32bit_point();
+
+    PhysicalAddress m_dmi_entry_point;
+    PhysicalAddress m_smbios_structure_table;
+    bool m_using_64bit_dmi_entry_point { false };
+    size_t m_smbios_structure_table_length { 0 };
+    size_t m_dmi_entry_point_length { 0 };
+};
+
+}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/BIOS.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/Directory.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/PowerStateSwitch.h>
+#include <Kernel/Firmware/ACPI/Parser.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT void FirmwareSysFSDirectory::initialize()
+{
+    auto firmware_directory = adopt_ref_if_nonnull(new (nothrow) FirmwareSysFSDirectory()).release_nonnull();
+    SysFSComponentRegistry::the().register_new_component(firmware_directory);
+    firmware_directory->create_components();
+}
+
+void FirmwareSysFSDirectory::create_components()
+{
+    m_components.append(BIOSSysFSDirectory::must_create(*this));
+    if (ACPI::is_enabled())
+        m_components.append(ACPI::ACPISysFSDirectory::must_create(*this));
+    m_components.append(PowerStateSwitchNode::must_create(*this));
+}
+
+UNMAP_AFTER_INIT FirmwareSysFSDirectory::FirmwareSysFSDirectory()
+    : SysFSDirectory(SysFSComponentRegistry::the().root_directory())
+{
+}
+
+}

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Types.h>
+#include <Kernel/FileSystem/SysFS.h>
+
+namespace Kernel {
+
+class FirmwareSysFSDirectory : public SysFSDirectory {
+public:
+    virtual StringView name() const override { return "firmware"sv; }
+    static void initialize();
+
+    void create_components();
+
+private:
+    FirmwareSysFSDirectory();
+};
+
+}

Kernel/FileSystem/SysFS/Subsystems/Firmware/PowerStateSwitch.cpp

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Arch/x86/IO.h>
+#include <Kernel/FileSystem/FileSystem.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/PowerStateSwitch.h>
+#include <Kernel/Firmware/ACPI/Parser.h>
+#include <Kernel/Process.h>
+#include <Kernel/Sections.h>
+#include <Kernel/TTY/ConsoleManagement.h>
+
+namespace Kernel {
+
+mode_t PowerStateSwitchNode::permissions() const
+{
+    return S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP;
+}
+
+UNMAP_AFTER_INIT NonnullRefPtr<PowerStateSwitchNode> PowerStateSwitchNode::must_create(FirmwareSysFSDirectory& firmware_directory)
+{
+    return adopt_ref_if_nonnull(new (nothrow) PowerStateSwitchNode(firmware_directory)).release_nonnull();
+}
+
+UNMAP_AFTER_INIT PowerStateSwitchNode::PowerStateSwitchNode(FirmwareSysFSDirectory&)
+    : SysFSComponent()
+{
+}
+
+ErrorOr<void> PowerStateSwitchNode::truncate(u64 size)
+{
+    // Note: This node doesn't store any useful data anyway, so we can safely
+    // truncate this to zero (essentially ignoring the request without failing).
+    if (size != 0)
+        return EPERM;
+    return {};
+}
+
+ErrorOr<size_t> PowerStateSwitchNode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& data, OpenFileDescription*)
+{
+    if (Checked<off_t>::addition_would_overflow(offset, count))
+        return EOVERFLOW;
+    if (offset > 0)
+        return EINVAL;
+    if (count > 1)
+        return EINVAL;
+
+    char buf[1];
+    TRY(data.read(buf, 1));
+    switch (buf[0]) {
+    case '0':
+        return EINVAL;
+    case '1':
+        reboot();
+        VERIFY_NOT_REACHED();
+    case '2':
+        poweroff();
+        VERIFY_NOT_REACHED();
+    default:
+        return EINVAL;
+    }
+    VERIFY_NOT_REACHED();
+}
+
+void PowerStateSwitchNode::reboot()
+{
+    MutexLocker locker(Process::current().big_lock());
+
+    dbgln("acquiring FS locks...");
+    FileSystem::lock_all();
+    dbgln("syncing mounted filesystems...");
+    FileSystem::sync();
+    dbgln("attempting reboot via ACPI");
+    if (ACPI::is_enabled())
+        ACPI::Parser::the()->try_acpi_reboot();
+    dbgln("attempting reboot via KB Controller...");
+    IO::out8(0x64, 0xFE);
+    dbgln("reboot attempts failed, applications will stop responding.");
+    dmesgln("Reboot can't be completed. It's safe to turn off the computer!");
+    Processor::halt();
+}
+
+void PowerStateSwitchNode::poweroff()
+{
+    MutexLocker locker(Process::current().big_lock());
+
+    ConsoleManagement::the().switch_to_debug();
+
+    dbgln("acquiring FS locks...");
+    FileSystem::lock_all();
+    dbgln("syncing mounted filesystems...");
+    FileSystem::sync();
+    dbgln("attempting system shutdown...");
+    // QEMU Shutdown
+    IO::out16(0x604, 0x2000);
+    // If we're here, the shutdown failed. Try VirtualBox shutdown.
+    IO::out16(0x4004, 0x3400);
+    // VirtualBox shutdown failed. Try Bochs/Old QEMU shutdown.
+    IO::out16(0xb004, 0x2000);
+    dbgln("shutdown attempts failed, applications will stop responding.");
+    dmesgln("Shutdown can't be completed. It's safe to turn off the computer!");
+    Processor::halt();
+}
+
+}

Kernel/FileSystem/SysFS/Subsystems/Firmware/PowerStateSwitch.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/RefPtr.h>
+#include <AK/Types.h>
+#include <AK/Vector.h>
+#include <Kernel/FileSystem/SysFS.h>
+#include <Kernel/FileSystem/SysFS/Subsystems/Firmware/Directory.h>
+#include <Kernel/KBuffer.h>
+#include <Kernel/Memory/MappedROM.h>
+#include <Kernel/Memory/Region.h>
+#include <Kernel/PhysicalAddress.h>
+#include <Kernel/VirtualAddress.h>
+
+namespace Kernel {
+
+class PowerStateSwitchNode final : public SysFSComponent {
+public:
+    virtual StringView name() const override { return "power_state"sv; }
+    static NonnullRefPtr<PowerStateSwitchNode> must_create(FirmwareSysFSDirectory&);
+    virtual mode_t permissions() const override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) override;
+    virtual ErrorOr<void> truncate(u64) override;
+    virtual ErrorOr<void> set_mtime(time_t) override { return {}; }
+
+private:
+    PowerStateSwitchNode(FirmwareSysFSDirectory&);
+
+    void reboot();
+    void poweroff();
+};
+
+}