Kernel: Move device lookup to Device class itself

Previously, VFS stored a list of all devices, and devices had to
register and unregister themselves with it. This cleans up things
a bit.

Kernel/Devices/Device.cpp

@@ -1,17 +1,40 @@
 #include <Kernel/Devices/Device.h>
-#include <Kernel/FileSystem/VirtualFileSystem.h>
+#include <Kernel/FileSystem/InodeMetadata.h>
 #include <LibC/errno_numbers.h>
 
+static HashMap<u32, Device*>* s_all_devices;
+
+HashMap<u32, Device*>& Device::all_devices()
+{
+    if (s_all_devices == nullptr)
+        s_all_devices = new HashMap<u32, Device*>;
+    return *s_all_devices;
+}
+
+void Device::for_each(Function<void(Device&)> callback)
+{
+    for (auto& entry : all_devices())
+        callback(*entry.value);
+}
+
+Device* Device::get_device(unsigned major, unsigned minor)
+{
+    auto it = all_devices().find(encoded_device(major, minor));
+    if (it == all_devices().end())
+        return nullptr;
+    return it->value;
+}
+
 Device::Device(unsigned major, unsigned minor)
     : m_major(major)
     , m_minor(minor)
 {
-    VFS::the().register_device({}, *this);
+    all_devices().set(encoded_device(m_major, m_minor), this);
 }
 
 Device::~Device()
 {
-    VFS::the().unregister_device({}, *this);
+    all_devices().remove(encoded_device(m_major, m_minor));
 }
 
 String Device::absolute_path() const

Kernel/Devices/Device.h

@@ -2,13 +2,14 @@
 
 // Device is the base class of everything that lives in the /dev directory.
 //
-// All Devices will automatically register with the VFS.
 // To expose a Device to the filesystem, simply pass two unique numbers to the constructor,
 // and then mknod a file in /dev with those numbers.
 //
 // There are two main subclasses:
 //   - BlockDevice (random access)
 //   - CharacterDevice (sequential)
+#include <AK/Function.h>
+#include <AK/HashMap.h>
 #include <Kernel/FileSystem/File.h>
 #include <Kernel/UnixTypes.h>
 
@@ -28,11 +29,16 @@ public:
     virtual bool is_device() const override { return true; }
     virtual bool is_disk_device() const { return false; }
 
+    static void for_each(Function<void(Device&)>);
+    static Device* get_device(unsigned major, unsigned minor);
+
 protected:
     Device(unsigned major, unsigned minor);
     void set_uid(uid_t uid) { m_uid = uid; }
     void set_gid(gid_t gid) { m_gid = gid; }
 
+    static HashMap<u32, Device*>& all_devices();
+
 private:
     unsigned m_major { 0 };
     unsigned m_minor { 0 };

Kernel/FileSystem/DevPtsFS.cpp

@@ -69,7 +69,7 @@ RefPtr<Inode> DevPtsFS::get_inode(InodeIdentifier inode_id) const
         return m_root_inode;
 
     unsigned pty_index = inode_index_to_pty_index(inode_id.index());
-    auto* device = VFS::the().get_device(11, pty_index);
+    auto* device = Device::get_device(11, pty_index);
     ASSERT(device);
 
     auto inode = adopt(*new DevPtsFSInode(const_cast<DevPtsFS&>(*this), inode_id.index()));

Kernel/FileSystem/VirtualFileSystem.cpp

@@ -216,11 +216,11 @@ KResultOr<NonnullRefPtr<FileDescription>> VFS::open(StringView path, int options
     }
 
     if (metadata.is_device()) {
-        auto it = m_devices.find(encoded_device(metadata.major_device, metadata.minor_device));
+        auto device = Device::get_device(metadata.major_device, metadata.minor_device);
-        if (it == m_devices.end()) {
+        if (device == nullptr) {
             return KResult(-ENODEV);
         }
-        auto descriptor_or_error = (*it).value->open(options);
+        auto descriptor_or_error = device->open(options);
         if (descriptor_or_error.is_error())
             return descriptor_or_error.error();
         descriptor_or_error.value()->set_original_inode({}, inode);
@@ -615,23 +615,6 @@ InodeIdentifier VFS::Mount::host() const
     return m_host_custody->inode().identifier();
 }
 
-void VFS::register_device(Badge<Device>, Device& device)
-{
-    m_devices.set(encoded_device(device.major(), device.minor()), &device);
-}
-
-void VFS::unregister_device(Badge<Device>, Device& device)
-{
-    m_devices.remove(encoded_device(device.major(), device.minor()));
-}
-
-Device* VFS::get_device(unsigned major, unsigned minor)
-{
-    auto it = m_devices.find(encoded_device(major, minor));
-    if (it == m_devices.end())
-        return nullptr;
-    return (*it).value;
-}
 
 void VFS::for_each_mount(Function<void(const Mount&)> callback) const
 {

Kernel/FileSystem/VirtualFileSystem.h

@@ -79,9 +79,6 @@ public:
     KResult mknod(StringView path, mode_t, dev_t, Custody& base);
     KResultOr<NonnullRefPtr<Custody>> open_directory(StringView path, Custody& base);
 
-    void register_device(Badge<Device>, Device&);
-    void unregister_device(Badge<Device>, Device&);
-
     size_t mount_count() const { return m_mounts.size(); }
     void for_each_mount(Function<void(const Mount&)>) const;
 
@@ -89,8 +86,6 @@ public:
 
     void sync();
 
-    Device* get_device(unsigned major, unsigned minor);
-
     Custody& root_custody();
     KResultOr<NonnullRefPtr<Custody>> resolve_path(StringView path, Custody& base, RefPtr<Custody>* parent = nullptr, int options = 0);
 
@@ -110,7 +105,6 @@ private:
 
     RefPtr<Inode> m_root_inode;
     NonnullOwnPtrVector<Mount> m_mounts;
-    HashMap<u32, Device*> m_devices;
 
     RefPtr<Custody> m_root_custody;
 };

Kernel/Process.cpp

@@ -2764,7 +2764,7 @@ int Process::sys$mount(const char* device_path, const char* mountpoint, const ch
         auto major = metadata_or_error.value().major_device;
         auto minor = metadata_or_error.value().minor_device;
 
-        auto* device = VFS::the().get_device(major, minor);
+        auto* device = Device::get_device(major, minor);
         if (!device) {
             dbg() << "mount: device (" << major << "," << minor << ") not found";
             return -ENODEV;