Kernel: Get rid of *LockRefPtr in the SysFS filesystem code

To do this we also need to get rid of LockRefPtrs in the USB code as
well.
Most of the SysFS nodes are statically generated during boot and are not
mutated afterwards.

The same goes for general device code - once we generate the appropriate
SysFS nodes, we almost never mutate the node pointers afterwards, making
locking unnecessary.

Author: supercomputer7

Kernel/Bus/USB/USBDevice.cpp

@@ -21,7 +21,9 @@ ErrorOr<NonnullLockRefPtr<Device>> Device::try_create(USBController const& contr
     auto pipe = TRY(ControlPipe::create(controller, 0, 8, 0));
     auto device = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) Device(controller, port, speed, move(pipe))));
     auto sysfs_node = TRY(SysFSUSBDeviceInformation::create(*device));
-    device->m_sysfs_device_info_node = move(sysfs_node);
+    device->m_sysfs_device_info_node.with([&](auto& node) {
+        node = move(sysfs_node);
+    });
     TRY(device->enumerate_device());
     return device;
 }

Kernel/Bus/USB/USBDevice.h

@@ -12,6 +12,7 @@
 #include <AK/Vector.h>
 #include <Kernel/Bus/USB/USBConfiguration.h>
 #include <Kernel/Bus/USB/USBPipe.h>
+#include <Kernel/Locking/SpinlockProtected.h>
 
 namespace Kernel {
 class SysFSUSBDeviceInformation;
@@ -57,7 +58,7 @@ class Device : public AtomicRefCounted<Device> {
 
     Vector<USBConfiguration> const& configurations() const { return m_configurations; }
 
-    SysFSUSBDeviceInformation& sysfs_device_info_node(Badge<USB::Hub>) { return *m_sysfs_device_info_node; }
+    SpinlockProtected<RefPtr<SysFSUSBDeviceInformation>, LockRank::None>& sysfs_device_info_node(Badge<USB::Hub>) { return m_sysfs_device_info_node; }
 
 protected:
     Device(NonnullLockRefPtr<USBController> controller, u8 address, u8 port, DeviceSpeed speed, NonnullOwnPtr<ControlPipe> default_pipe);
@@ -79,7 +80,7 @@ class Device : public AtomicRefCounted<Device> {
     IntrusiveListNode<Device, NonnullLockRefPtr<Device>> m_hub_child_node;
 
 protected:
-    LockRefPtr<SysFSUSBDeviceInformation> m_sysfs_device_info_node;
+    SpinlockProtected<RefPtr<SysFSUSBDeviceInformation>, LockRank::None> m_sysfs_device_info_node;
 
 public:
     using List = IntrusiveList<&Device::m_hub_child_node>;

Kernel/Bus/USB/USBHub.cpp

@@ -46,7 +46,10 @@ ErrorOr<void> Hub::enumerate_and_power_on_hub()
     // USBDevice::enumerate_device must be called before this.
     VERIFY(m_address > 0);
 
-    m_sysfs_device_info_node = TRY(SysFSUSBDeviceInformation::create(*this));
+    TRY(m_sysfs_device_info_node.with([&](auto& node) -> ErrorOr<void> {
+        node = TRY(SysFSUSBDeviceInformation::create(*this));
+        return {};
+    }));
 
     if (m_device_descriptor.device_class != USB_CLASS_HUB) {
         dbgln("USB Hub: Trying to enumerate and power on a device that says it isn't a hub.");
@@ -133,8 +136,11 @@ ErrorOr<void> Hub::set_port_feature(u8 port, HubFeatureSelector feature_selector
 
 void Hub::remove_children_from_sysfs()
 {
-    for (auto& child : m_children)
-        SysFSUSBBusDirectory::the().unplug({}, child.sysfs_device_info_node({}));
+    for (auto& child : m_children) {
+        child.sysfs_device_info_node({}).with([](auto& node) {
+            SysFSUSBBusDirectory::the().unplug({}, *node);
+        });
+    }
 }
 
 void Hub::check_for_port_updates()
@@ -260,10 +266,14 @@ void Hub::check_for_port_updates()
 
                     auto hub = hub_or_error.release_value();
                     m_children.append(hub);
-                    SysFSUSBBusDirectory::the().plug({}, hub->sysfs_device_info_node({}));
+                    hub->sysfs_device_info_node({}).with([](auto& node) {
+                        SysFSUSBBusDirectory::the().plug({}, *node);
+                    });
                 } else {
                     m_children.append(device);
-                    SysFSUSBBusDirectory::the().plug({}, device->sysfs_device_info_node({}));
+                    device->sysfs_device_info_node({}).with([](auto& node) {
+                        SysFSUSBBusDirectory::the().plug({}, *node);
+                    });
                 }
 
             } else {
@@ -278,7 +288,9 @@ void Hub::check_for_port_updates()
                 }
 
                 if (device_to_remove) {
-                    SysFSUSBBusDirectory::the().unplug({}, device_to_remove->sysfs_device_info_node({}));
+                    device_to_remove->sysfs_device_info_node({}).with([](auto& node) {
+                        SysFSUSBBusDirectory::the().unplug({}, *node);
+                    });
                     if (device_to_remove->device_descriptor().device_class == USB_CLASS_HUB) {
                         auto* hub_child = static_cast<Hub*>(device_to_remove.ptr());
                         hub_child->remove_children_from_sysfs();

Kernel/Devices/Device.cpp

@@ -34,19 +34,19 @@ void Device::after_inserting_add_to_device_management()
 
 ErrorOr<void> Device::after_inserting()
 {
-    after_inserting_add_to_device_management();
     VERIFY(!m_sysfs_component);
     auto sys_fs_component = SysFSDeviceComponent::must_create(*this);
     m_sysfs_component = sys_fs_component;
     after_inserting_add_to_device_identifier_directory();
+    after_inserting_add_to_device_management();
     return {};
 }
 
 void Device::will_be_destroyed()
 {
     VERIFY(m_sysfs_component);
-    before_will_be_destroyed_remove_from_device_identifier_directory();
     before_will_be_destroyed_remove_from_device_management();
+    before_will_be_destroyed_remove_from_device_identifier_directory();
 }
 
 Device::~Device()

Kernel/Devices/Device.h

@@ -96,10 +96,10 @@ class Device : public File {
 protected:
     // FIXME: This pointer will be eventually removed after all nodes in /sys/dev/block/ and
     // /sys/dev/char/ are symlinks.
-    LockRefPtr<SysFSDeviceComponent> m_sysfs_component;
+    RefPtr<SysFSDeviceComponent> m_sysfs_component;
 
-    LockRefPtr<SysFSSymbolicLinkDeviceComponent> m_symlink_sysfs_component;
-    LockRefPtr<SysFSDirectory> m_sysfs_device_directory;
+    RefPtr<SysFSSymbolicLinkDeviceComponent> m_symlink_sysfs_component;
+    RefPtr<SysFSDirectory> m_sysfs_device_directory;
 };
 
 }

Kernel/FileSystem/SysFS/Component.cpp

@@ -74,8 +74,6 @@ ErrorOr<size_t> SysFSSymbolicLink::read_bytes(off_t offset, size_t count, UserOr
 ErrorOr<NonnullOwnPtr<KBuffer>> SysFSSymbolicLink::try_to_generate_buffer() const
 {
     auto return_path_to_mount_point = TRY(try_generate_return_path_to_mount_point());
-    if (!m_pointed_component)
-        return Error::from_errno(EIO);
     auto pointed_component_base_name = MUST(KString::try_create(m_pointed_component->name()));
     auto pointed_component_relative_path = MUST(m_pointed_component->relative_path(move(pointed_component_base_name), 0));
     auto full_return_and_target_path = TRY(KString::formatted("{}{}", return_path_to_mount_point->view(), pointed_component_relative_path->view()));
@@ -126,9 +124,9 @@ ErrorOr<void> SysFSDirectory::traverse_as_directory(FileSystemID fsid, Function<
     });
 }
 
-LockRefPtr<SysFSComponent> SysFSDirectory::lookup(StringView name)
+RefPtr<SysFSComponent> SysFSDirectory::lookup(StringView name)
 {
-    return m_child_components.with([&](auto& list) -> LockRefPtr<SysFSComponent> {
+    return m_child_components.with([&](auto& list) -> RefPtr<SysFSComponent> {
         for (auto& child_component : list) {
             if (child_component.name() == name) {
                 return child_component;

Kernel/FileSystem/SysFS/Component.h

@@ -9,13 +9,13 @@
 #include <AK/AtomicRefCounted.h>
 #include <AK/Error.h>
 #include <AK/Function.h>
+#include <AK/RefPtr.h>
 #include <AK/StringView.h>
 #include <AK/Types.h>
 #include <Kernel/FileSystem/File.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Forward.h>
-#include <Kernel/Library/LockRefPtr.h>
 
 namespace Kernel {
 
@@ -31,7 +31,7 @@ class SysFSComponent : public AtomicRefCounted<SysFSComponent> {
     virtual StringView name() const = 0;
     virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const { return Error::from_errno(ENOTIMPL); }
     virtual ErrorOr<void> traverse_as_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const { VERIFY_NOT_REACHED(); }
-    virtual LockRefPtr<SysFSComponent> lookup(StringView) { VERIFY_NOT_REACHED(); };
+    virtual RefPtr<SysFSComponent> lookup(StringView) { VERIFY_NOT_REACHED(); };
     virtual mode_t permissions() const;
     virtual ErrorOr<void> truncate(u64) { return EPERM; }
     virtual size_t size() const { return 0; }
@@ -51,9 +51,9 @@ class SysFSComponent : public AtomicRefCounted<SysFSComponent> {
     explicit SysFSComponent(SysFSDirectory const& parent_directory);
     SysFSComponent();
 
-    LockRefPtr<SysFSDirectory> m_parent_directory;
+    RefPtr<SysFSDirectory> const m_parent_directory;
 
-    IntrusiveListNode<SysFSComponent, NonnullLockRefPtr<SysFSComponent>> m_list_node;
+    IntrusiveListNode<SysFSComponent, NonnullRefPtr<SysFSComponent>> m_list_node;
 
 private:
     InodeIndex m_component_index {};
@@ -70,13 +70,13 @@ class SysFSSymbolicLink : public SysFSComponent {
 
     explicit SysFSSymbolicLink(SysFSDirectory const& parent_directory, SysFSComponent const& pointed_component);
 
-    LockRefPtr<SysFSComponent> m_pointed_component;
+    NonnullRefPtr<SysFSComponent> const m_pointed_component;
 };
 
 class SysFSDirectory : public SysFSComponent {
 public:
     virtual ErrorOr<void> traverse_as_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override final;
-    virtual LockRefPtr<SysFSComponent> lookup(StringView name) override final;
+    virtual RefPtr<SysFSComponent> lookup(StringView name) override final;
 
     virtual ErrorOr<NonnullRefPtr<SysFSInode>> to_inode(SysFS const& sysfs_instance) const override final;
 

Kernel/FileSystem/SysFS/Inode.h

@@ -40,7 +40,7 @@ class SysFSInode : public Inode {
     virtual ErrorOr<void> attach(OpenFileDescription& description) override final;
     virtual void did_seek(OpenFileDescription&, off_t) override final;
 
-    NonnullLockRefPtr<SysFSComponent> m_associated_component;
+    NonnullRefPtr<SysFSComponent> const m_associated_component;
 };
 
 }

Kernel/FileSystem/SysFS/Registry.cpp

@@ -45,7 +45,6 @@ SysFSBusDirectory& SysFSComponentRegistry::buses_directory()
 
 void SysFSComponentRegistry::register_new_bus_directory(SysFSDirectory& new_bus_directory)
 {
-    VERIFY(!m_root_directory->m_buses_directory.is_null());
     MUST(m_root_directory->m_buses_directory->m_child_components.with([&](auto& list) -> ErrorOr<void> {
         list.append(new_bus_directory);
         return {};

Kernel/FileSystem/SysFS/Registry.h

@@ -31,7 +31,7 @@ class SysFSComponentRegistry {
     SysFSBusDirectory& buses_directory();
 
 private:
-    NonnullLockRefPtr<SysFSRootDirectory> m_root_directory;
+    NonnullRefPtr<SysFSRootDirectory> const m_root_directory;
     Spinlock<LockRank::None> m_root_directory_lock {};
 };