kapi/device: remove major and minor

33 files changed, 74 insertions, 168 deletions

diff --git a/arch/x86_64/arch/bus/isa.cpp b/arch/x86_64/arch/bus/isa.cpp
index f6cc72dc..dd248f76 100644
--- a/arch/x86_64/arch/bus/isa.cpp
+++ b/arch/x86_64/arch/bus/isa.cpp
@@ -2,13 +2,11 @@
 
 #include <kapi/devices.hpp>
 
-#include <cstddef>
-
 namespace arch::bus
 {
 
-  isa::isa(std::size_t major)
-      : kapi::devices::bus{major, 0, "isa"}
+  isa::isa()
+      : kapi::devices::bus{"isa"}
   {}
 
 }  // namespace arch::bus
\ No newline at end of file
diff --git a/arch/x86_64/arch/bus/isa.hpp b/arch/x86_64/arch/bus/isa.hpp
index e56f56a2..5741a640 100644
--- a/arch/x86_64/arch/bus/isa.hpp
+++ b/arch/x86_64/arch/bus/isa.hpp
@@ -3,14 +3,12 @@
 
 #include <kapi/devices/bus.hpp>
 
-#include <cstddef>
-
 namespace arch::bus
 {
 
   struct isa final : public kapi::devices::bus
   {
-    isa(std::size_t major);
+    isa();
   };
 
 }  // namespace arch::bus
diff --git a/arch/x86_64/arch/devices/init.cpp b/arch/x86_64/arch/devices/init.cpp
index 134d6dac..4ac287cf 100644
--- a/arch/x86_64/arch/devices/init.cpp
+++ b/arch/x86_64/arch/devices/init.cpp
@@ -62,11 +62,9 @@ namespace arch::devices
   {
     kstd::println("[x86_64:DEV] Initializing ISA bus...");
 
-    auto isa_major_number = kapi::devices::allocate_major_number();
-    auto isa_bus = kstd::make_unique<arch::bus::isa>(isa_major_number);
+    auto isa_bus = kstd::make_unique<arch::bus::isa>();
 
-    auto pit_major_number = kapi::devices::allocate_major_number();
-    auto pit = kstd::make_unique<arch::devices::legacy_pit>(pit_major_number, pit_frequency_in_hz);
+    auto pit = kstd::make_unique<arch::devices::legacy_pit>(pit_frequency_in_hz);
     isa_bus->add_child(std::move(pit));
 
     auto & root_bus = kapi::devices::get_root_bus();
diff --git a/arch/x86_64/arch/devices/legacy_pit.cpp b/arch/x86_64/arch/devices/legacy_pit.cpp
index d542d475..d93b38fd 100644
--- a/arch/x86_64/arch/devices/legacy_pit.cpp
+++ b/arch/x86_64/arch/devices/legacy_pit.cpp
@@ -6,7 +6,6 @@
 #include <kapi/devices/device.hpp>
 #include <kapi/interrupts.hpp>
 
-#include <cstddef>
 #include <cstdint>
 
 namespace arch::devices
@@ -23,8 +22,8 @@ namespace arch::devices
     constexpr auto square_wave_mode = 0x36;
   }  // namespace
 
-  legacy_pit::legacy_pit(std::size_t major, std::uint32_t frequency_in_hz)
-      : kapi::devices::device{major, 0, "legacy_pit"}
+  legacy_pit::legacy_pit(std::uint32_t frequency_in_hz)
+      : kapi::devices::device{"legacy_pit"}
       , m_irq_number{0}
       , m_frequency_in_hz{frequency_in_hz}
   {}
diff --git a/arch/x86_64/arch/devices/legacy_pit.hpp b/arch/x86_64/arch/devices/legacy_pit.hpp
index 356895c7..7a74144e 100644
--- a/arch/x86_64/arch/devices/legacy_pit.hpp
+++ b/arch/x86_64/arch/devices/legacy_pit.hpp
@@ -4,7 +4,6 @@
 #include <kapi/devices/device.hpp>
 #include <kapi/interrupts.hpp>
 
-#include <cstddef>
 #include <cstdint>
 
 namespace arch::devices
@@ -12,7 +11,7 @@ namespace arch::devices
 
   struct legacy_pit : kapi::devices::device, kapi::interrupts::handler
   {
-    legacy_pit(std::size_t major, std::uint32_t frequency_in_hz);
+    explicit legacy_pit(std::uint32_t frequency_in_hz);
 
     auto init() -> bool override;
 
diff --git a/arch/x86_64/arch/devices/local_apic.cpp b/arch/x86_64/arch/devices/local_apic.cpp
index f3ab8d32..e7108f8f 100644
--- a/arch/x86_64/arch/devices/local_apic.cpp
+++ b/arch/x86_64/arch/devices/local_apic.cpp
@@ -3,6 +3,7 @@
 #include <kapi/devices.hpp>
 #include <kapi/memory.hpp>
 
+#include <kstd/format.hpp>
 #include <kstd/print.hpp>
 
 #include <cstddef>
@@ -74,9 +75,9 @@ namespace arch::devices
     divide_configuration = 0x3e0,
   };
 
-  local_apic::local_apic(std::size_t major, std::size_t minor, std::uint64_t core_index, std::uint64_t hardware_id,
-                         kapi::memory::physical_address base, bool is_bsp)
-      : kapi::devices::device{major, minor, "lapic"}
+  local_apic::local_apic(std::uint64_t core_index, std::uint64_t hardware_id, kapi::memory::physical_address base,
+                         bool is_bsp)
+      : kapi::devices::device{kstd::format("lapic{}", core_index)}
       , m_core_index{core_index}
       , m_hardware_id{hardware_id}
       , m_base{base}
diff --git a/arch/x86_64/arch/devices/local_apic.hpp b/arch/x86_64/arch/devices/local_apic.hpp
index 3a2d5417..4b82050b 100644
--- a/arch/x86_64/arch/devices/local_apic.hpp
+++ b/arch/x86_64/arch/devices/local_apic.hpp
@@ -12,8 +12,7 @@ namespace arch::devices
 
   struct local_apic : kapi::devices::device
   {
-    local_apic(std::size_t major, std::size_t minor, std::uint64_t core_index, std::uint64_t hardware_id,
-               kapi::memory::physical_address base, bool is_bsp);
+    local_apic(std::uint64_t core_index, std::uint64_t hardware_id, kapi::memory::physical_address base, bool is_bsp);
 
     auto init() -> bool override;
 
diff --git a/arch/x86_64/kapi/cpu.cpp b/arch/x86_64/kapi/cpu.cpp
index 787a230e..bd86f0fa 100644
--- a/arch/x86_64/kapi/cpu.cpp
+++ b/arch/x86_64/kapi/cpu.cpp
@@ -48,10 +48,6 @@ namespace kapi::cpu
 
   auto discover_topology() -> bool
   {
-    auto static const cpu_major = kapi::devices::allocate_major_number();
-    auto static const core_major = kapi::devices::allocate_major_number();
-    auto static const interrupt_controller_major = kapi::devices::allocate_major_number();
-
     auto madt = kapi::acpi::get_table<::acpi::table_signature_v<::acpi::madt>>();
     if (!madt)
     {
@@ -68,16 +64,14 @@ namespace kapi::cpu
     auto bsp_found = false;
     auto core_index = 0uz;
     auto local_apic_address = memory::physical_address{madt->local_interrupt_controller_address()};
-    auto cpu_bus = kstd::make_unique<devices::cpu>(cpu_major, 0);
+    auto cpu_bus = kstd::make_unique<devices::cpu>();
 
     for (auto const & apic : lapic_entries)
     {
       auto is_bsp = !bsp_found;
       bsp_found = true;
-      auto core =
-          kstd::make_unique<devices::cpu::core>(core_major, core_index, core_index, apic.processor_id(), is_bsp);
-      core->add_child(kstd::make_unique<arch::devices::local_apic>(interrupt_controller_major, core_index, core_index,
-                                                                   apic.id(), local_apic_address, is_bsp));
+      auto core = kstd::make_unique<devices::cpu::core>(core_index, apic.processor_id(), is_bsp);
+      core->add_child(kstd::make_unique<arch::devices::local_apic>(core_index, apic.id(), local_apic_address, is_bsp));
       cpu_bus->add_child(std::move(core));
       ++core_index;
     }
diff --git a/kapi/kapi/devices/bus.hpp b/kapi/kapi/devices/bus.hpp
index c4777616..913149fb 100644
--- a/kapi/kapi/devices/bus.hpp
+++ b/kapi/kapi/devices/bus.hpp
@@ -11,7 +11,6 @@
 #include <kstd/vector.hpp>
 
 #include <atomic>
-#include <cstddef>
 
 namespace kapi::devices
 {
@@ -24,10 +23,8 @@ namespace kapi::devices
   {
     //! Construct a bus with the given major number, minor number, and name.
     //!
-    //! @param major The major number of the bus.
-    //! @param minor The minor number of the bus.
     //! @param name The name of the bus.
-    bus(std::size_t major, std::size_t minor, kstd::string const & name);
+    explicit bus(kstd::string const & name);
 
     //! Initialize the bus and all of its children.
     //!
diff --git a/kapi/kapi/devices/cpu.hpp b/kapi/kapi/devices/cpu.hpp
index 5f4228cc..708c803e 100644
--- a/kapi/kapi/devices/cpu.hpp
+++ b/kapi/kapi/devices/cpu.hpp
@@ -3,7 +3,6 @@
 
 #include <kapi/devices/bus.hpp>
 
-#include <cstddef>
 #include <cstdint>
 
 namespace kapi::devices
@@ -15,7 +14,7 @@ namespace kapi::devices
     //! A virtual CPU Core to host all core local devices.
     struct core final : kapi::devices::bus
     {
-      explicit core(std::size_t major, std::size_t minor, std::uint64_t index, std::uint64_t hardware_id, bool is_bsp);
+      core(std::uint64_t index, std::uint64_t hardware_id, bool is_bsp);
 
       [[nodiscard]] auto hardware_id() const -> std::uint64_t;
       [[nodiscard]] auto is_bsp() const -> bool;
@@ -27,11 +26,8 @@ namespace kapi::devices
       bool m_is_bsp;
     };
 
-    //! Create a new CPU with the given major and minor numbers.
-    //!
-    //! @param major The major number of this CPU
-    //! @param minor The minor number of this CPU, identifying the physical CPU
-    cpu(std::size_t major, std::size_t minor);
+    //! Create a new CPU.
+    cpu();
   };
 
 }  // namespace kapi::devices
diff --git a/kapi/kapi/devices/device.hpp b/kapi/kapi/devices/device.hpp
index bf91dfcf..34254002 100644
--- a/kapi/kapi/devices/device.hpp
+++ b/kapi/kapi/devices/device.hpp
@@ -8,8 +8,6 @@
 #include <kstd/memory.hpp>
 #include <kstd/string.hpp>
 
-#include <cstddef>
-
 namespace kapi::devices
 {
 
@@ -23,11 +21,9 @@ namespace kapi::devices
   {
     /**
      * @brief Create a device identifier from @p major, @p minor and @p name.
-     * @param major Device major number.
-     * @param minor Device minor number.
      * @param name Device name.
      */
-    device(size_t major, size_t minor, kstd::string const & name);
+    explicit device(kstd::string const & name);
 
     /**
      * @brief Virtual destructor for device.
@@ -59,18 +55,6 @@ namespace kapi::devices
     }
 
     /**
-     * @brief Returns the major number of the device.
-     * @return Device major number.
-     */
-    [[nodiscard]] auto major() const -> size_t;
-
-    /**
-     * @brief Returns the minor number of the device.
-     * @return Device minor number.
-     */
-    [[nodiscard]] auto minor() const -> size_t;
-
-    /**
      * @brief Returns the name of the device.
      * @return Device name.
      */
@@ -84,8 +68,6 @@ namespace kapi::devices
 
     auto set_parent(kstd::observer_ptr<struct bus> parent) -> void;
 
-    size_t m_major;
-    size_t m_minor;
     kstd::string m_name;
     kstd::observer_ptr<bus> m_parent;
   };
diff --git a/kapi/kapi/devices/manager.hpp b/kapi/kapi/devices/manager.hpp
index c317b61e..499b79ab 100644
--- a/kapi/kapi/devices/manager.hpp
+++ b/kapi/kapi/devices/manager.hpp
@@ -33,13 +33,6 @@ namespace kapi::devices
   //! @return true if the device was unregistered successfully, false otherwise.
   auto unregister_device(device & device) -> bool;
 
-  //! Find a device by its major and minor numbers.
-  //!
-  //! @param major the major number of the device.
-  //! @param minor the minor number of the device.
-  //! @return a pointer to the device iff. the device was found, nullptr otherwise.
-  auto find_device(std::size_t major, std::size_t minor) -> kstd::observer_ptr<device>;
-
   //! Find a device by its name.
   //!
   //! @param name the name of the device.
diff --git a/kernel/kapi/devices.cpp b/kernel/kapi/devices.cpp
index ef72c667..ae2d4d7a 100644
--- a/kernel/kapi/devices.cpp
+++ b/kernel/kapi/devices.cpp
@@ -8,6 +8,7 @@
 #include <kstd/flat_map.hpp>
 #include <kstd/memory.hpp>
 #include <kstd/print.hpp>
+#include <kstd/string.hpp>
 
 #include <atomic>
 #include <cstddef>
@@ -21,7 +22,7 @@ namespace kapi::devices
   {
     auto constinit next_major_number = std::atomic_size_t{1};
     auto constinit root_bus = std::optional<kernel::devices::root_bus>{};
-    auto constinit device_tree = kstd::flat_map<std::pair<std::size_t, std::size_t>, kstd::observer_ptr<device>>{};
+    auto constinit device_tree = kstd::flat_map<kstd::string, kstd::observer_ptr<device>>{};
   }  // namespace
 
   auto init() -> void
@@ -54,8 +55,8 @@ namespace kapi::devices
 
   auto register_device(device & device) -> bool
   {
-    kstd::println("[OS:DEV] Registering device {}@{}:{}", device.name(), device.major(), device.minor());
-    return device_tree.emplace(std::pair{device.major(), device.minor()}, &device).second;
+    kstd::println("[OS:DEV] Registering device {}", device.name());
+    return device_tree.emplace(device.name(), &device).second;
   }
 
   auto unregister_device(device &) -> bool
@@ -64,15 +65,6 @@ namespace kapi::devices
     return false;
   }
 
-  auto find_device(std::size_t major, std::size_t minor) -> kstd::observer_ptr<device>
-  {
-    if (device_tree.contains(std::pair{major, minor}))
-    {
-      return device_tree.at(std::pair{major, minor});
-    }
-    return nullptr;
-  }
-
   auto find_device(std::string_view name) -> kstd::observer_ptr<device>
   {
     for (auto const & [key, value] : device_tree)
diff --git a/kernel/kapi/devices/bus.cpp b/kernel/kapi/devices/bus.cpp
index 4695ae39..d9f3f991 100644
--- a/kernel/kapi/devices/bus.cpp
+++ b/kernel/kapi/devices/bus.cpp
@@ -9,26 +9,25 @@
 #include <kstd/vector.hpp>
 
 #include <algorithm>
-#include <cstddef>
 #include <utility>
 
 namespace kapi::devices
 {
-  bus::bus(std::size_t major, std::size_t minor, kstd::string const & name)
-      : device(major, minor, name)
+  bus::bus(kstd::string const & name)
+      : device{name}
   {}
 
   auto bus::init() -> bool
   {
     if (m_init_was_called.test_and_set())
     {
-      kstd::println(kstd::print_sink::stderr, "[OS:DEV] Bus {}:{}:{} already initialized", name(), major(), minor());
+      kstd::println(kstd::print_sink::stderr, "[OS:DEV] Bus {} already initialized", name());
       return true;
     }
 
     if (!enumerate())
     {
-      kstd::println(kstd::print_sink::stderr, "[OS:DEV] Bus {}:{}:{} enumeration failed", name(), major(), minor());
+      kstd::println(kstd::print_sink::stderr, "[OS:DEV] Bus {} enumeration failed", name());
       return false;
     }
 
@@ -47,7 +46,10 @@ namespace kapi::devices
     auto observer = m_observers.emplace_back(child.get());
     child->set_parent(kstd::make_observer(this));
     m_devices.push_back(std::move(child));
-    kapi::devices::register_device(*observer);
+    if (!kapi::devices::register_device(*observer))
+    {
+      kapi::system::panic("[OS:DEV] Failed to register child device");
+    }
 
     if (m_initialized.test())
     {
diff --git a/kernel/kapi/devices/cpu.cpp b/kernel/kapi/devices/cpu.cpp
index 457b9d56..daba34a8 100644
--- a/kernel/kapi/devices/cpu.cpp
+++ b/kernel/kapi/devices/cpu.cpp
@@ -2,14 +2,15 @@
 
 #include <kapi/devices.hpp>
 
-#include <cstddef>
+#include <kstd/format.hpp>
+
 #include <cstdint>
 
 namespace kapi::devices
 {
 
-  cpu::core::core(std::size_t major, std::size_t minor, std::uint64_t index, std::uint64_t hardware_id, bool is_bsp)
-      : kapi::devices::bus{major, minor, "cpu_core"}
+  cpu::core::core(std::uint64_t index, std::uint64_t hardware_id, bool is_bsp)
+      : kapi::devices::bus{kstd::format("cpu_core{}", index)}
       , m_index{index}
       , m_hardware_id{hardware_id}
       , m_is_bsp{is_bsp}
@@ -30,8 +31,8 @@ namespace kapi::devices
     return m_is_bsp;
   }
 
-  cpu::cpu(std::size_t major, std::size_t minor)
-      : kapi::devices::bus{major, minor, "cpu"}
+  cpu::cpu()
+      : kapi::devices::bus{"cpu"}
   {}
 
 }  // namespace kapi::devices
\ No newline at end of file
diff --git a/kernel/kapi/devices/device.cpp b/kernel/kapi/devices/device.cpp
index 6ac92e79..0d00d8fd 100644
--- a/kernel/kapi/devices/device.cpp
+++ b/kernel/kapi/devices/device.cpp
@@ -6,26 +6,12 @@
 #include <kstd/memory.hpp>
 #include <kstd/string.hpp>
 
-#include <cstddef>
-
 namespace kapi::devices
 {
-  device::device(size_t major, size_t minor, kstd::string const & name)
-      : m_major(major)
-      , m_minor(minor)
-      , m_name(name)
+  device::device(kstd::string const & name)
+      : m_name(name)
   {}
 
-  [[nodiscard]] auto device::major() const -> size_t
-  {
-    return m_major;
-  }
-
-  [[nodiscard]] auto device::minor() const -> size_t
-  {
-    return m_minor;
-  }
-
   [[nodiscard]] auto device::name() const -> kstd::string const &
   {
     return m_name;
diff --git a/kernel/kapi/devices/interface_registry.tests.cpp b/kernel/kapi/devices/interface_registry.tests.cpp
index ffd9f0d6..aea7776c 100644
--- a/kernel/kapi/devices/interface_registry.tests.cpp
+++ b/kernel/kapi/devices/interface_registry.tests.cpp
@@ -30,7 +30,7 @@ namespace
   struct test_device final : kapi::devices::device, probe_device
   {
     explicit test_device(int value, const_device & const_device)
-        : device{0, 0, "probeable"}
+        : device{"probeable"}
         , m_value{value}
         , m_const_device{&const_device}
     {}
diff --git a/kernel/kernel/devices/block_device_utils.tests.cpp b/kernel/kernel/devices/block_device_utils.tests.cpp
index fd68a63b..7d671c7e 100644
--- a/kernel/kernel/devices/block_device_utils.tests.cpp
+++ b/kernel/kernel/devices/block_device_utils.tests.cpp
@@ -21,7 +21,7 @@ SCENARIO("reading from a block device with block_device_utils", "[devices][block
   GIVEN("a block device with known data")
   {
     auto const block_size = 512_B;
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "test_block_device", block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("test_block_device", block_size);
     kstd::vector<uint8_t> block_data(block_size.value);
     for (size_t i = 0; i < block_data.size(); ++i)
     {
@@ -108,7 +108,7 @@ SCENARIO("writing to a block device using block_device_utils", "[devices][block_
   {
     auto const block_size = 512_B;
     auto device =
-        kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "test_block_device", block_size, 2 * block_size);
+        kstd::make_shared<kernel::tests::devices::block_device>("test_block_device", block_size, 2 * block_size);
 
     WHEN("writing to the block device using block_device_utils")
     {
diff --git a/kernel/kernel/devices/root_bus.cpp b/kernel/kernel/devices/root_bus.cpp
index 1b754f23..9a0b0776 100644
--- a/kernel/kernel/devices/root_bus.cpp
+++ b/kernel/kernel/devices/root_bus.cpp
@@ -6,7 +6,7 @@ namespace kernel::devices
 {
 
   root_bus::root_bus()
-      : kapi::devices::bus{0, 0, "system"}
+      : kapi::devices::bus{"system"}
   {}
 
 }  // namespace kernel::devices
\ No newline at end of file
diff --git a/kernel/kernel/devices/storage/controller.cpp b/kernel/kernel/devices/storage/controller.cpp
index 5ea9eb71..f2b67938 100644
--- a/kernel/kernel/devices/storage/controller.cpp
+++ b/kernel/kernel/devices/storage/controller.cpp
@@ -5,7 +5,6 @@
 #include <kstd/memory.hpp>
 #include <kstd/vector.hpp>
 
-#include <algorithm>
 #include <cstddef>
 
 namespace kernel::devices::storage
@@ -21,17 +20,6 @@ namespace kernel::devices::storage
     return m_major;
   }
 
-  auto controller::device_by_minor(size_t minor) const -> kstd::shared_ptr<kapi::devices::device>
-  {
-    auto it = std::ranges::find_if(m_devices, [minor](auto const & device) { return device->minor() == minor; });
-
-    if (it != m_devices.end())
-    {
-      return *it;
-    }
-    return nullptr;
-  }
-
   auto controller::devices_count() const -> size_t
   {
     return m_devices.size();
diff --git a/kernel/kernel/devices/storage/controller.hpp b/kernel/kernel/devices/storage/controller.hpp
index 13494a52..770c1997 100644
--- a/kernel/kernel/devices/storage/controller.hpp
+++ b/kernel/kernel/devices/storage/controller.hpp
@@ -53,14 +53,6 @@ namespace kernel::devices::storage
      */
     [[nodiscard]] auto all_devices() const -> kstd::vector<kstd::shared_ptr<kapi::devices::device>> const &;
 
-    /**
-     * @brief Find a managed device by major/minor numbers.
-     * @param major Device major number.
-     * @param minor Device minor number.
-     * @return Matching block device, or nullptr if no device matches.
-     */
-    [[nodiscard]] auto device_by_minor(size_t minor) const -> kstd::shared_ptr<kapi::devices::device>;
-
   protected:
     size_t m_major{};
     size_t m_minors_per_device{};
diff --git a/kernel/kernel/devices/storage/ram_disk/controller.cpp b/kernel/kernel/devices/storage/ram_disk/controller.cpp
index 905279a4..afae9ef2 100644
--- a/kernel/kernel/devices/storage/ram_disk/controller.cpp
+++ b/kernel/kernel/devices/storage/ram_disk/controller.cpp
@@ -22,8 +22,7 @@ namespace kernel::devices::storage::ram_disk
     size_t current_device_index = 0;
 
     std::ranges::for_each(*m_boot_module_registry, [this, &current_device_index](auto const & module) {
-      auto const minor = current_device_index++;
-      auto const disk = kstd::make_shared<device>(module, m_major, minor, minor);
+      auto const disk = kstd::make_shared<device>(module, current_device_index++);
       disk->init();
 
       if (auto published = kapi::devices::publish_interface<kapi::devices::block_device>(disk, disk->name());
diff --git a/kernel/kernel/devices/storage/ram_disk/device.cpp b/kernel/kernel/devices/storage/ram_disk/device.cpp
index f9fa60bb..a9de0a2e 100644
--- a/kernel/kernel/devices/storage/ram_disk/device.cpp
+++ b/kernel/kernel/devices/storage/ram_disk/device.cpp
@@ -22,8 +22,8 @@ namespace kernel::devices::storage::ram_disk
     constexpr auto ram_disk_block_size = 512_B;
   }  // namespace
 
-  device::device(kapi::boot_modules::boot_module const & module, size_t major, size_t minor, std::size_t device_index)
-      : kapi::devices::device(major, minor, kstd::format("ram{}", device_index))
+  device::device(kapi::boot_modules::boot_module const & module, std::size_t device_index)
+      : kapi::devices::device{kstd::format("ram{}", device_index)}
       , m_boot_module(module)
   {}
 
diff --git a/kernel/kernel/devices/storage/ram_disk/device.hpp b/kernel/kernel/devices/storage/ram_disk/device.hpp
index 0bb09875..e4f99633 100644
--- a/kernel/kernel/devices/storage/ram_disk/device.hpp
+++ b/kernel/kernel/devices/storage/ram_disk/device.hpp
@@ -19,10 +19,8 @@ namespace kernel::devices::storage::ram_disk
     /**
      * @brief Create a RAM disk for the @p module.
      * @param module Boot module providing the memory region.
-     * @param major Device major number.
-     * @param minor Device minor number.
      */
-    device(kapi::boot_modules::boot_module const & module, size_t major, size_t minor, std::size_t device_index);
+    device(kapi::boot_modules::boot_module const & module, std::size_t device_index);
 
     /**
      * @brief Initialize the RAM disk device.
diff --git a/kernel/kernel/devices/storage/ram_disk/device.tests.cpp b/kernel/kernel/devices/storage/ram_disk/device.tests.cpp
index a10dc84e..115afd86 100644
--- a/kernel/kernel/devices/storage/ram_disk/device.tests.cpp
+++ b/kernel/kernel/devices/storage/ram_disk/device.tests.cpp
@@ -22,7 +22,7 @@ SCENARIO("RAM Disk Device Construction and Initialization", "[ram_disk_device]")
 
     WHEN("constructing the device")
     {
-      kernel::devices::storage::ram_disk::device device{boot_module, 0, 0, 0};
+      kernel::devices::storage::ram_disk::device device{boot_module, 0};
 
       THEN("init return false")
       {
@@ -39,7 +39,7 @@ SCENARIO("RAM Disk Device Construction and Initialization", "[ram_disk_device]")
 
     WHEN("constructing the device")
     {
-      kernel::devices::storage::ram_disk::device device{boot_module, 0, 0, 0};
+      kernel::devices::storage::ram_disk::device device{boot_module, 0};
 
       THEN("init return true")
       {
@@ -56,7 +56,7 @@ SCENARIO("RAM Disk Device Read and Write", "[ram_disk_device]")
     auto storage = std::vector{4096, std::byte{0xff}};
     auto module =
         kapi::boot_modules::boot_module{"test_module", kapi::memory::linear_address{storage.data()}, storage.size()};
-    auto device = kernel::devices::storage::ram_disk::device{module, 0, 0, 0};
+    auto device = kernel::devices::storage::ram_disk::device{module, 0};
     REQUIRE(device.init());
 
     WHEN("reading a full block from the device")
diff --git a/kernel/kernel/filesystem/device_inode.tests.cpp b/kernel/kernel/filesystem/device_inode.tests.cpp
index b0d0659f..e821ce1d 100644
--- a/kernel/kernel/filesystem/device_inode.tests.cpp
+++ b/kernel/kernel/filesystem/device_inode.tests.cpp
@@ -21,7 +21,7 @@ SCENARIO("Device inode construction", "[filesystem][device_inode]")
 {
   GIVEN("a block device")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "test_block_device", 512_B, 3 * 512_B);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("test_block_device", 512_B, 3 * 512_B);
 
     WHEN("constructing a device inode with the block device")
     {
@@ -55,7 +55,7 @@ SCENARIO("Device inode read/write", "[filesystem][device_inode]")
 {
   GIVEN("a block device and a device inode for that device")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "test_block_device", 512_B, 3 * 512_B);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("test_block_device", 512_B, 3 * 512_B);
     auto inode = kernel::filesystem::device_inode{device};
 
     WHEN("writing to the device inode")
@@ -89,7 +89,7 @@ SCENARIO("Device inode read/write with a non-block device", "[filesystem][device
 {
   GIVEN("a non-block device and a device inode for that device")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::character_device>(0, 0, "test_character_device");
+    auto device = kstd::make_shared<kernel::tests::devices::character_device>("test_character_device");
     auto inode = kernel::filesystem::device_inode{device};
 
     WHEN("reading from the device inode")
diff --git a/kernel/kernel/filesystem/device_number_registry.tests.cpp b/kernel/kernel/filesystem/device_number_registry.tests.cpp
index 7090860e..67e09831 100644
--- a/kernel/kernel/filesystem/device_number_registry.tests.cpp
+++ b/kernel/kernel/filesystem/device_number_registry.tests.cpp
@@ -28,7 +28,7 @@ SCENARIO("Device number registry resolves and numbers published block devices",
 
   GIVEN("A single block device has been published")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "ram0", 512_B);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("ram0", 512_B);
     CHECK(interfaces.publish<kapi::devices::block_device>(device, "ram0"));
 
     THEN("all() returns a vector with one element")
@@ -65,7 +65,7 @@ SCENARIO("Device number registry resolves and numbers published block devices",
 
     THEN("number_of() fails on a device that has never been published")
     {
-      auto not_published = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "ram1", 512_B);
+      auto not_published = kstd::make_shared<kernel::tests::devices::block_device>("ram1", 512_B);
 
       REQUIRE(!registry.number_of(*not_published));
     }
@@ -73,7 +73,7 @@ SCENARIO("Device number registry resolves and numbers published block devices",
 
   GIVEN("A device was published")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "ram0", 512_B);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("ram0", 512_B);
     CHECK(interfaces.publish<kapi::devices::block_device>(device, "ram0"));
     auto number = registry.number_of(*device);
 
diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
index 9013ea22..bf408d55 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
@@ -174,7 +174,7 @@ SCENARIO("Ext2 filesystem rejects invalid magic", "[filesystem][ext2][filesystem
   auto const block_size = 1024_B;
   GIVEN("a block device that does not contain an ext2 superblock")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 2 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 2 * block_size);
     REQUIRE(device);
 
     auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
@@ -194,7 +194,7 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys
 
   GIVEN("a minimally valid ext2 layout with configured indirect block tables")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 128 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 128 * block_size);
     REQUIRE(device);
 
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
@@ -246,7 +246,7 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
 
   GIVEN("a mounted ext2 filesystem with free blocks available for indirect table allocation")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 256 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 256 * block_size);
     REQUIRE(device);
 
     auto superblock = kernel::filesystem::ext2::superblock{};
diff --git a/kernel/kernel/filesystem/ext2/inode.tests.cpp b/kernel/kernel/filesystem/ext2/inode.tests.cpp
index e3c06407..e587d75e 100644
--- a/kernel/kernel/filesystem/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.tests.cpp
@@ -140,7 +140,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
   auto const block_size = 1024_B;
   GIVEN("an ext2 inode with only direct mapped data blocks")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 64 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
 
@@ -178,7 +178,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
 
   GIVEN("an ext2 indode with file holes in singly indirect blocks")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 64 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
 
@@ -223,7 +223,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
 
   GIVEN("an ext2 inode with zero singly indirect block pointer")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 64 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
 
@@ -254,7 +254,7 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]")
   auto const block_size = 1024_B;
   GIVEN("an ext2 inode with two direct blocks and a block size of 1024 bytes")
   {
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 64 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
 
@@ -362,7 +362,7 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
 {
   auto const block_size = 1024_B;
 
-  auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 128 * block_size);
+  auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 128 * block_size);
   REQUIRE(device != nullptr);
 
   auto superblock = kernel::filesystem::ext2::superblock{};
@@ -520,7 +520,7 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
   {
     superblock.rev_level = 0;
 
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 64 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock);
 
@@ -563,7 +563,7 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
   {
     superblock.rev_level = 1;
 
-    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "mock", block_size, 64 * block_size);
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock);
 
diff --git a/kernel/kernel/test_support/devices/block_device.cpp b/kernel/kernel/test_support/devices/block_device.cpp
index f20ac48d..3052a26d 100644
--- a/kernel/kernel/test_support/devices/block_device.cpp
+++ b/kernel/kernel/test_support/devices/block_device.cpp
@@ -17,9 +17,8 @@ using namespace kstd::units_literals;
 
 namespace kernel::tests::devices
 {
-  block_device::block_device(size_t major, size_t minor, kstd::string const & name, kstd::units::bytes block_size,
-                             kstd::units::bytes initial_size)
-      : kapi::devices::device{major, minor, name}
+  block_device::block_device(kstd::string const & name, kstd::units::bytes block_size, kstd::units::bytes initial_size)
+      : kapi::devices::device{name}
       , m_block_size{block_size}
   {
     data.resize(initial_size.value, 0);
diff --git a/kernel/kernel/test_support/devices/block_device.hpp b/kernel/kernel/test_support/devices/block_device.hpp
index 082ab003..c3a05aef 100644
--- a/kernel/kernel/test_support/devices/block_device.hpp
+++ b/kernel/kernel/test_support/devices/block_device.hpp
@@ -16,8 +16,7 @@ namespace kernel::tests::devices
 
   struct block_device final : kapi::devices::device, kapi::devices::block_device
   {
-    block_device(size_t major, size_t minor, kstd::string const & name, kstd::units::bytes block_size,
-                 kstd::units::bytes initial_size = {});
+    block_device(kstd::string const & name, kstd::units::bytes block_size, kstd::units::bytes initial_size = {});
 
     auto init() -> bool override;
 
diff --git a/kernel/kernel/test_support/devices/character_device.cpp b/kernel/kernel/test_support/devices/character_device.cpp
index fef5baf5..a433fe2d 100644
--- a/kernel/kernel/test_support/devices/character_device.cpp
+++ b/kernel/kernel/test_support/devices/character_device.cpp
@@ -4,12 +4,10 @@
 
 #include <kstd/string.hpp>
 
-#include <cstddef>
-
 namespace kernel::tests::devices
 {
-  character_device::character_device(size_t major, size_t minor, kstd::string const & name)
-      : kapi::devices::device(major, minor, name)
+  character_device::character_device(kstd::string const & name)
+      : kapi::devices::device{name}
   {}
 
   auto character_device::init() -> bool
diff --git a/kernel/kernel/test_support/devices/character_device.hpp b/kernel/kernel/test_support/devices/character_device.hpp
index 5790a561..fe4b9370 100644
--- a/kernel/kernel/test_support/devices/character_device.hpp
+++ b/kernel/kernel/test_support/devices/character_device.hpp
@@ -6,14 +6,12 @@
 #include <kstd/string.hpp>
 #include <kstd/vector.hpp>
 
-#include <cstddef>
-
 namespace kernel::tests::devices
 {
   // TODO fix inheritance when character devices are implemented
   struct character_device : kapi::devices::device
   {
-    character_device(size_t major, size_t minor, kstd::string const & name);
+    character_device(kstd::string const & name);
 
     auto init() -> bool override;
   };