kapi: rename block and character device

12 files changed, 35 insertions, 32 deletions

diff --git a/kernel/kernel/devices/block_device_utils.cpp b/kernel/kernel/devices/block_device_utils.cpp
index 83bb8144..ee01d5c7 100644
--- a/kernel/kernel/devices/block_device_utils.cpp
+++ b/kernel/kernel/devices/block_device_utils.cpp
@@ -20,11 +20,11 @@ namespace kernel::devices::block_device_utils
   {
     using block_op = kstd::result<kstd::units::bytes> (*)(size_t idx, kstd::units::bytes off, kstd::units::bytes len,
                                                           kstd::units::bytes done,
-                                                          kapi::filesystem::block_device & device, std::byte * scratch,
-                                                          void * buffer);
+                                                          kapi::filesystem::block_special_file & device,
+                                                          std::byte * scratch, void * buffer);
 
-    auto process_blocks(kapi::filesystem::block_device & device, kstd::units::bytes offset, kstd::units::bytes size,
-                        void * buffer, block_op op) -> kstd::result<kstd::units::bytes>
+    auto process_blocks(kapi::filesystem::block_special_file & device, kstd::units::bytes offset,
+                        kstd::units::bytes size, void * buffer, block_op op) -> kstd::result<kstd::units::bytes>
     {
       if (buffer == nullptr)
       {
@@ -69,7 +69,7 @@ namespace kernel::devices::block_device_utils
     }
   }  // namespace
 
-  auto calculate_transfer(kapi::filesystem::block_device const & device, size_t block_index) -> transfer_info
+  auto calculate_transfer(kapi::filesystem::block_special_file const & device, size_t block_index) -> transfer_info
   {
     auto const offset = block_index * device.block_size();
     auto const limit = device.capacity();
@@ -80,12 +80,12 @@ namespace kernel::devices::block_device_utils
     return {offset, to_transfer, device.block_size() - to_transfer};
   }
 
-  auto read(kapi::filesystem::block_device & device, void * buffer, kstd::units::bytes offset, kstd::units::bytes size)
-      -> kstd::result<kstd::units::bytes>
+  auto read(kapi::filesystem::block_special_file & device, void * buffer, kstd::units::bytes offset,
+            kstd::units::bytes size) -> kstd::result<kstd::units::bytes>
   {
     return process_blocks(device, offset, size, buffer,
                           [](size_t idx, kstd::units::bytes off, kstd::units::bytes len, kstd::units::bytes done,
-                             kapi::filesystem::block_device & device, std::byte * scratch, void * buffer) {
+                             kapi::filesystem::block_special_file & device, std::byte * scratch, void * buffer) {
                             auto * out = static_cast<std::byte *>(buffer);
                             if (off == 0_B && len == device.block_size())
                             {
@@ -103,12 +103,12 @@ namespace kernel::devices::block_device_utils
                           });
   }
 
-  auto write(kapi::filesystem::block_device & device, void const * buffer, kstd::units::bytes offset,
+  auto write(kapi::filesystem::block_special_file & device, void const * buffer, kstd::units::bytes offset,
              kstd::units::bytes size) -> kstd::result<kstd::units::bytes>
   {
     return process_blocks(device, offset, size, const_cast<void *>(buffer),
                           [](size_t idx, kstd::units::bytes off, kstd::units::bytes len, kstd::units::bytes done,
-                             kapi::filesystem::block_device & device, std::byte * scratch, void * buffer) {
+                             kapi::filesystem::block_special_file & device, std::byte * scratch, void * buffer) {
                             auto const * in = static_cast<std::byte const *>(buffer);
                             if (off == 0_B && len == device.block_size())
                             {
diff --git a/kernel/kernel/devices/block_device_utils.hpp b/kernel/kernel/devices/block_device_utils.hpp
index 240cb20d..cafe0f3e 100644
--- a/kernel/kernel/devices/block_device_utils.hpp
+++ b/kernel/kernel/devices/block_device_utils.hpp
@@ -28,7 +28,7 @@ namespace kernel::devices::block_device_utils
     kstd::units::bytes remainder;
   };
 
-  [[nodiscard]] auto calculate_transfer(kapi::filesystem::block_device const & device, size_t block_index)
+  [[nodiscard]] auto calculate_transfer(kapi::filesystem::block_special_file const & device, size_t block_index)
       -> transfer_info;
 
   /**
@@ -40,8 +40,8 @@ namespace kernel::devices::block_device_utils
   @param size The number of bytes to read.
   @return The number of bytes actually read, which may be less than the requested size.
   */
-  auto read(kapi::filesystem::block_device & device, void * buffer, kstd::units::bytes offset, kstd::units::bytes size)
-      -> kstd::result<kstd::units::bytes>;
+  auto read(kapi::filesystem::block_special_file & device, void * buffer, kstd::units::bytes offset,
+            kstd::units::bytes size) -> kstd::result<kstd::units::bytes>;
 
   /**
   @brief Writes data from a @p buffer to a @p device, starting at a specific @p offset and for a given @p size.
@@ -52,7 +52,7 @@ namespace kernel::devices::block_device_utils
   @param size The number of bytes to write.
   @return The number of bytes actually written, which may be less than the requested size.
   */
-  auto write(kapi::filesystem::block_device & device, void const * buffer, kstd::units::bytes offset,
+  auto write(kapi::filesystem::block_special_file & device, void const * buffer, kstd::units::bytes offset,
              kstd::units::bytes size) -> kstd::result<kstd::units::bytes>;
 }  // namespace kernel::devices::block_device_utils
 
diff --git a/kernel/kernel/devices/storage.cpp b/kernel/kernel/devices/storage.cpp
index 12d5639c..4f5776d2 100644
--- a/kernel/kernel/devices/storage.cpp
+++ b/kernel/kernel/devices/storage.cpp
@@ -18,7 +18,7 @@ namespace kernel::devices::storage
 
   auto determine_boot_device() -> kstd::shared_ptr<kapi::devices::device>
   {
-    auto block_devices = kapi::devices::interface_registry::get().all(kapi::filesystem::block_device::id);
+    auto block_devices = kapi::devices::interface_registry::get().all(kapi::filesystem::block_special_file::id);
     if (block_devices.empty())
     {
       return nullptr;
diff --git a/kernel/kernel/devices/storage.tests.cpp b/kernel/kernel/devices/storage.tests.cpp
index 754457b9..3cf21b01 100644
--- a/kernel/kernel/devices/storage.tests.cpp
+++ b/kernel/kernel/devices/storage.tests.cpp
@@ -29,7 +29,7 @@ TEST_CASE("Storage devices attached with init() are reachable from the root bus"
 
   bus->add_child(device);
 
-  auto block_devices = kapi::devices::interface_registry::get().all(kapi::filesystem::block_device::id);
+  auto block_devices = kapi::devices::interface_registry::get().all(kapi::filesystem::block_special_file::id);
   REQUIRE(block_devices.size() == 1);
   CHECK(block_devices[0].name() == "ram0");
 
diff --git a/kernel/kernel/drivers/storage/ram_disk.cpp b/kernel/kernel/drivers/storage/ram_disk.cpp
index 6c9bed0d..4c9f412d 100644
--- a/kernel/kernel/drivers/storage/ram_disk.cpp
+++ b/kernel/kernel/drivers/storage/ram_disk.cpp
@@ -31,7 +31,7 @@ namespace kernel::drivers::storage
   {
     constexpr auto default_block_size = 512_B;
 
-    struct block_node final : kapi::filesystem::block_device
+    struct block_node final : kapi::filesystem::block_special_file
     {
       explicit block_node(kapi::boot_modules::module const & module)
           : m_module(module)
@@ -111,15 +111,15 @@ namespace kernel::drivers::storage
     auto implementation = kstd::make_shared<struct block_node>(module);
 
     auto next_index =
-        std::ranges::count_if(kapi::devices::interface_registry::get().all(kapi::filesystem::block_device::id),
+        std::ranges::count_if(kapi::devices::interface_registry::get().all(kapi::filesystem::block_special_file::id),
                               [this](auto const & published) {
                                 auto published_device = published.device();
                                 return published_device && published_device->bound_driver() == this;
                               });
     auto name = kstd::format("ram{}", next_index);
 
-    auto published = kapi::devices::publish_interface<kapi::filesystem::block_device>(device.shared_from_this(), name,
-                                                                                      implementation.get());
+    auto published = kapi::devices::publish_interface<kapi::filesystem::block_special_file>(device.shared_from_this(),
+                                                                                            name, implementation.get());
     if (!published)
     {
       return published;
@@ -132,7 +132,7 @@ namespace kernel::drivers::storage
 
   auto ram_disk::unbind(kapi::devices::device & device) -> void
   {
-    kapi::devices::interface_registry::get().unpublish(device, kapi::filesystem::block_device::id);
+    kapi::devices::interface_registry::get().unpublish(device, kapi::filesystem::block_special_file::id);
     device.set_driver_data(nullptr);
   }
 
diff --git a/kernel/kernel/filesystem/device_inode.cpp b/kernel/kernel/filesystem/device_inode.cpp
index c68e8d8d..ce0ad3fe 100644
--- a/kernel/kernel/filesystem/device_inode.cpp
+++ b/kernel/kernel/filesystem/device_inode.cpp
@@ -41,7 +41,8 @@ namespace kernel::filesystem
   auto device_inode::read(void * buffer, kstd::units::bytes offset, kstd::units::bytes size) const
       -> kstd::result<kstd::units::bytes>
   {
-    if (auto block_device = kapi::devices::interface_registry::get().resolve<kapi::filesystem::block_device>(*m_device))
+    if (auto block_device =
+            kapi::devices::interface_registry::get().resolve<kapi::filesystem::block_special_file>(*m_device))
     {
       return devices::block_device_utils::read(*block_device, buffer, offset, size);
     }
@@ -52,7 +53,8 @@ namespace kernel::filesystem
   auto device_inode::write(void const * buffer, kstd::units::bytes offset, kstd::units::bytes size)
       -> kstd::result<kstd::units::bytes>
   {
-    if (auto block_device = kapi::devices::interface_registry::get().resolve<kapi::filesystem::block_device>(*m_device))
+    if (auto block_device =
+            kapi::devices::interface_registry::get().resolve<kapi::filesystem::block_special_file>(*m_device))
     {
       return devices::block_device_utils::write(*block_device, buffer, offset, size);
     }
diff --git a/kernel/kernel/filesystem/device_inode.tests.cpp b/kernel/kernel/filesystem/device_inode.tests.cpp
index f859bb1a..5f409a79 100644
--- a/kernel/kernel/filesystem/device_inode.tests.cpp
+++ b/kernel/kernel/filesystem/device_inode.tests.cpp
@@ -172,7 +172,7 @@ SCENARIO("Device inode raw_device()", "[filesystem][device-inode]")
 
     CHECK(kernel::tests::devices::bind(*device, std::uint8_t{1}));
 
-    REQUIRE(kapi::devices::interface_registry::get().publish<kapi::filesystem::block_device>(device, "ram0"));
+    REQUIRE(kapi::devices::interface_registry::get().publish<kapi::filesystem::block_special_file>(device, "ram0"));
 
     auto inode = kernel::filesystem::device_inode{device};
 
diff --git a/kernel/kernel/filesystem/device_number_registry.tests.cpp b/kernel/kernel/filesystem/device_number_registry.tests.cpp
index 262330e3..3791a16e 100644
--- a/kernel/kernel/filesystem/device_number_registry.tests.cpp
+++ b/kernel/kernel/filesystem/device_number_registry.tests.cpp
@@ -28,7 +28,7 @@ namespace
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>(name, block_size);
     [[maybe_unused]] auto driver = kernel::tests::devices::bind(*device, major);
-    if (!interfaces.publish<kapi::filesystem::block_device>(device, name))
+    if (!interfaces.publish<kapi::filesystem::block_special_file>(device, name))
     {
       throw std::runtime_error{"failed to publish block device!"};
     }
@@ -145,7 +145,7 @@ SCENARIO("Device number registry resolves and numbers published block devices",
   GIVEN("A published device with no bound driver at all")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("unbound0", 512_B);
-    CHECK(interfaces.publish<kapi::filesystem::block_device>(device, "unbound0"));
+    CHECK(interfaces.publish<kapi::filesystem::block_special_file>(device, "unbound0"));
 
     THEN("it is never numbered")
     {
diff --git a/kernel/kernel/filesystem/file_type_bindings.hpp b/kernel/kernel/filesystem/file_type_bindings.hpp
index 9ef4d77f..9c76b3d8 100644
--- a/kernel/kernel/filesystem/file_type_bindings.hpp
+++ b/kernel/kernel/filesystem/file_type_bindings.hpp
@@ -23,7 +23,7 @@ namespace kernel::filesystem
   //!
   //! This array associates published interfaces with files types.
   constexpr auto inline file_type_bindings = std::array{
-    file_type_binding{kapi::filesystem::block_device::id, file_type::block},
+    file_type_binding{kapi::filesystem::block_special_file::id, file_type::block},
   };
 
 }  // namespace kernel::filesystem
diff --git a/kernel/kernel/test_support/devices/block_device.cpp b/kernel/kernel/test_support/devices/block_device.cpp
index 48414aae..2cde621c 100644
--- a/kernel/kernel/test_support/devices/block_device.cpp
+++ b/kernel/kernel/test_support/devices/block_device.cpp
@@ -70,9 +70,9 @@ namespace kernel::tests::devices
 
   auto block_device::query_interface(kapi::devices::interface_id interface) -> void *
   {
-    if (interface == kapi::filesystem::block_device::id)
+    if (interface == kapi::filesystem::block_special_file::id)
     {
-      return static_cast<kapi::filesystem::block_device *>(this);
+      return static_cast<kapi::filesystem::block_special_file *>(this);
     }
 
     return kapi::devices::device::query_interface(interface);
diff --git a/kernel/kernel/test_support/devices/block_device.hpp b/kernel/kernel/test_support/devices/block_device.hpp
index fed7b2bd..9546b0cc 100644
--- a/kernel/kernel/test_support/devices/block_device.hpp
+++ b/kernel/kernel/test_support/devices/block_device.hpp
@@ -15,7 +15,7 @@
 namespace kernel::tests::devices
 {
 
-  struct block_device final : kapi::devices::device, kapi::filesystem::block_device
+  struct block_device final : kapi::devices::device, kapi::filesystem::block_special_file
   {
     block_device(kstd::string const & name, kstd::units::bytes block_size, kstd::units::bytes initial_size = {});
 
diff --git a/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.cpp b/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.cpp
index 79011450..e19c3a69 100644
--- a/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.cpp
+++ b/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.cpp
@@ -103,7 +103,8 @@ namespace kernel::tests::filesystem
       m_boot_module_bus->add_child(kstd::make_shared<kapi::boot_modules::device>(i, module));
     }
 
-    if (module_count > 0 && kapi::devices::interface_registry::get().all(kapi::filesystem::block_device::id).empty())
+    if (module_count > 0 &&
+        kapi::devices::interface_registry::get().all(kapi::filesystem::block_special_file::id).empty())
     {
       throw std::runtime_error{"No RAM disk driver bound to any of the test fixture's boot modules."};
     }
@@ -128,7 +129,7 @@ namespace kernel::tests::filesystem
     }
 
     if (!module_names.empty() &&
-        kapi::devices::interface_registry::get().all(kapi::filesystem::block_device::id).empty())
+        kapi::devices::interface_registry::get().all(kapi::filesystem::block_special_file::id).empty())
     {
       throw std::runtime_error{"No RAM disk driver bound to any of the test fixture's boot modules."};
     }