kernel: improve support for raw device files

19 files changed, 143 insertions, 107 deletions

diff --git a/kernel/kernel/filesystem/devfs/filesystem.cpp b/kernel/kernel/filesystem/devfs/filesystem.cpp
index 5003dde6..01cebfb3 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.cpp
@@ -2,6 +2,7 @@
 
 #include <kernel/filesystem/devfs/inode.hpp>
 #include <kernel/filesystem/device_inode.hpp>
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/device_number_registry.hpp>
 #include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/filesystem.hpp>
@@ -16,6 +17,7 @@
 #include <kstd/system_error.hpp>
 
 #include <algorithm>
+#include <optional>
 #include <string_view>
 
 namespace kernel::filesystem::devfs
@@ -84,7 +86,7 @@ namespace kernel::filesystem::devfs
   }
 
   auto filesystem::create_inode(kstd::shared_ptr<kernel::filesystem::inode> const &, std::string_view,
-                                kernel::filesystem::vfs_types::inode_type)
+                                vfs_types::inode_type, std::optional<device_number>)
       -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
     return kstd::failure(vfs_errc::read_only_file_system);
diff --git a/kernel/kernel/filesystem/devfs/filesystem.hpp b/kernel/kernel/filesystem/devfs/filesystem.hpp
index be3c119c..cb6b912c 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.hpp
@@ -2,6 +2,7 @@
 #define TEACH_OS_KERNEL_FILESYSTEM_DEVFS_FILESYSTEM_HPP
 
 #include <kernel/filesystem/device_inode.hpp>
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/inode.hpp>
 #include <kernel/filesystem/vfs_types.hpp>
@@ -11,43 +12,32 @@
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
+#include <optional>
 #include <string_view>
 
 namespace kernel::filesystem::devfs
 {
-  /**
-  @brief A filesystem for managing device nodes in the virtual filesystem. This filesystem provides a way to represent
-  devices as files in the /dev directory, allowing user-space applications to interact with devices using standard file
-  operations. The devfs filesystem dynamically creates inodes for devices registered in the system, enabling seamless
-  access to device functionality through the filesystem interface.
-  */
+
+  //! A filesystem for managing device nodes in the virtual filesystem.
+  //!
+  //! This filesystem provides a way to represent devices as files in the /dev directory, allowing user-space
+  //! applications to interact with devices using standard file operations. The devfs filesystem dynamically creates
+  //! inodes for devices registered in the system, enabling seamless access to device functionality through the
+  //! filesystem interface.
   struct filesystem : kernel::filesystem::filesystem
   {
-    /**
-    @brief Initializes the devfs instance and builds the device inode table.
-    @param backing_inode Backing inode passed by the vfs (not required by devfs).
-    @return The result of the mount operation.
-    */
+    //! @copydoc kernel::filesystem::filesystem::mount
     auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode) -> kstd::result<void> override;
 
-    /**
-    @brief Looks up an inode by @p name within a @p parent directory.
-    @param parent The parent directory inode.
-    @param name The name of the inode to look up.
-    @return A pointer to the found inode, or a null pointer if not found.
-    */
+    //! @copydoc kernel::filesystem::filesystem::lookup
     [[nodiscard]] auto lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
         -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
 
-    /**
-    @brief Creates a new inode with @p name within a @p parent directory.
-    @param parent The parent directory inode.
-    @param name The name of the inode to create.
-    @param inode_type The type of inode to be created.
-    @return Always returns nullptr, as creating new inodes is not supported in devfs.
-    */
+    //! @copydoc kernel::filesystem::filesystem::create_inode
+    //! @return Always returns an error, as creating new inodes is not supported in devfs.
     [[nodiscard]] auto create_inode(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name,
-                                    kernel::filesystem::vfs_types::inode_type inode_type)
+                                    vfs_types::inode_type inode_type,
+                                    std::optional<device_number> raw_device = std::nullopt)
         -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
 
   private:
diff --git a/kernel/kernel/filesystem/devfs/filesystem.tests.cpp b/kernel/kernel/filesystem/devfs/filesystem.tests.cpp
index 1028b6ba..b37b3800 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.tests.cpp
@@ -6,6 +6,8 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <optional>
+
 SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
                 "Devfs filesystem lookup uses storage management devices", "[filesystem][devfs][filesystem]")
 {
@@ -56,7 +58,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
 
     THEN("create_inode always returns an error")
     {
-      auto result = fs.create_inode(fs.root_inode(), "new_device", kernel::filesystem::vfs_types::inode_type::device);
+      auto result = fs.create_inode(fs.root_inode(), "new_device", kernel::filesystem::vfs_types::inode_type::regular);
       REQUIRE(!result);
     }
   }
diff --git a/kernel/kernel/filesystem/device_inode.cpp b/kernel/kernel/filesystem/device_inode.cpp
index d2444ef0..464c5ea9 100644
--- a/kernel/kernel/filesystem/device_inode.cpp
+++ b/kernel/kernel/filesystem/device_inode.cpp
@@ -49,7 +49,7 @@ namespace kernel::filesystem
     return m_device;
   }
 
-  auto device_inode::is_device() const -> bool
+  auto device_inode::is_block_device() const -> bool
   {
     return true;
   }
diff --git a/kernel/kernel/filesystem/device_inode.hpp b/kernel/kernel/filesystem/device_inode.hpp
index 23b9863d..be9fc577 100644
--- a/kernel/kernel/filesystem/device_inode.hpp
+++ b/kernel/kernel/filesystem/device_inode.hpp
@@ -56,7 +56,7 @@ namespace kernel::filesystem
     @brief Check if this inode represents a device.
     @return returns true, since this inode is a device inode and represents a device.
     */
-    [[nodiscard]] auto is_device() const -> bool override;
+    [[nodiscard]] auto is_block_device() const -> bool override;
 
   private:
     kstd::shared_ptr<kapi::devices::device> m_device;
diff --git a/kernel/kernel/filesystem/error.cpp b/kernel/kernel/filesystem/error.cpp
index 5512a5af..80ad1097 100644
--- a/kernel/kernel/filesystem/error.cpp
+++ b/kernel/kernel/filesystem/error.cpp
@@ -52,6 +52,8 @@ namespace kernel::filesystem
             return "file already exists";
           case vfs_errc::no_such_device:
             return "no such device";
+          case vfs_errc::invalid_argument:
+            return "invalid argument";
           default:
             return "unknown VFS error";
         }
@@ -64,6 +66,7 @@ namespace kernel::filesystem
           case vfs_errc::invalid_path:
           case vfs_errc::invalid_filesystem:
           case vfs_errc::invalid_inode:
+          case vfs_errc::invalid_argument:
             return make_error_condition(kstd::errc::invalid_argument);
           case vfs_errc::no_such_file_or_directory:
           case vfs_errc::mount_point_not_found:
diff --git a/kernel/kernel/filesystem/error.hpp b/kernel/kernel/filesystem/error.hpp
index 8c9d9e0b..0ebb1920 100644
--- a/kernel/kernel/filesystem/error.hpp
+++ b/kernel/kernel/filesystem/error.hpp
@@ -26,6 +26,7 @@ namespace kernel::filesystem
     read_only_file_system,
     file_exists,
     no_such_device,
+    invalid_argument,
   };
 
   [[nodiscard]] auto vfs_category() noexcept -> kstd::error_category const &;
diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index 89dac095..9ea2f3d4 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -1,5 +1,6 @@
 #include <kernel/filesystem/ext2/filesystem.hpp>
 
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/ext2/block_group_descriptor.hpp>
 #include <kernel/filesystem/ext2/error.hpp>
@@ -24,6 +25,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <expected>
+#include <optional>
 #include <string_view>
 #include <tuple>
 
@@ -170,7 +172,7 @@ namespace kernel::filesystem::ext2
   }
 
   auto filesystem::create_inode(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name,
-                                kernel::filesystem::vfs_types::inode_type inode_type)
+                                vfs_types::inode_type inode_type, std::optional<device_number> raw_device)
       -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
     if (!parent)
@@ -183,6 +185,14 @@ namespace kernel::filesystem::ext2
       return kstd::failure(vfs_errc::not_a_directory);
     }
 
+    auto is_device = inode_type == vfs_types::inode_type::block_device ||  //
+                     inode_type == vfs_types::inode_type::character_device;
+
+    if (is_device && !raw_device)
+    {
+      return kstd::failure(vfs_errc::invalid_argument);
+    }
+
     auto * ext2_parent = static_cast<inode *>(parent.get());
     if (!ext2_parent)
     {
@@ -207,6 +217,12 @@ namespace kernel::filesystem::ext2
     new_inode_data.blocks = 0;
     new_inode_data.block.fill(0);
 
+    if (is_device)
+    {
+      new_inode_data.block[0] = static_cast<std::uint32_t>(raw_device->minor) |  //
+                                (static_cast<std::uint32_t>(raw_device->major) << 8);
+    }
+
     // TODO preallocate blocks depending on type and m_superblock.prealloc_dir_blocks or m_superblock.prealloc_blocks;
 
     if (auto result = add_directory_entry(ext2_parent, name, inode_number, new_inode_data.mode); !result)
@@ -739,6 +755,10 @@ namespace kernel::filesystem::ext2
         return mode | constants::mode_directory;
       case kernel::filesystem::vfs_types::inode_type::regular:
         return mode | constants::mode_regular;
+      case kernel::filesystem::vfs_types::inode_type::block_device:
+        return mode | constants::mode_block_device;
+      case kernel::filesystem::vfs_types::inode_type::character_device:
+        return mode | constants::mode_character_device;
       case kernel::filesystem::vfs_types::inode_type::symbolic_link:
         // return mode | constants::mode_symbolic_link; // TODO implement
       default:
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index 23e56143..3e0a6992 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -1,6 +1,7 @@
 #ifndef TEACH_OS_KERNEL_FILESYSTEM_EXT2_FILESYSTEM_HPP
 #define TEACH_OS_KERNEL_FILESYSTEM_EXT2_FILESYSTEM_HPP
 
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/ext2/block_group_descriptor.hpp>
 #include <kernel/filesystem/ext2/inode.hpp>
 #include <kernel/filesystem/ext2/superblock.hpp>
@@ -17,6 +18,7 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
+#include <optional>
 #include <string_view>
 
 namespace kernel::filesystem::ext2
@@ -44,6 +46,8 @@ namespace kernel::filesystem::ext2
     constexpr uint16_t inline mode_regular = 0x8000;
     constexpr uint16_t inline mode_directory = 0x4000;
     constexpr uint16_t inline mode_symbolic_link = 0xA000;
+    constexpr uint16_t inline mode_block_device = 0x6000;
+    constexpr uint16_t inline mode_character_device = 0x2000;
   }  // namespace constants
 
   /**
@@ -76,7 +80,8 @@ namespace kernel::filesystem::ext2
     @return A pointer to the created inode, or a null pointer if creation failed.
     */
     [[nodiscard]] auto create_inode(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name,
-                                    kernel::filesystem::vfs_types::inode_type inode_type)
+                                    vfs_types::inode_type inode_type,
+                                    std::optional<device_number> raw_device = std::nullopt)
         -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
 
     /**
diff --git a/kernel/kernel/filesystem/filesystem.hpp b/kernel/kernel/filesystem/filesystem.hpp
index aa6286bf..fc122be6 100644
--- a/kernel/kernel/filesystem/filesystem.hpp
+++ b/kernel/kernel/filesystem/filesystem.hpp
@@ -1,6 +1,7 @@
 #ifndef TEACH_OS_KERNEL_FILESYSTEM_FILESYSTEM_HPP
 #define TEACH_OS_KERNEL_FILESYSTEM_FILESYSTEM_HPP
 
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/inode.hpp>
 #include <kernel/filesystem/vfs_types.hpp>
 
@@ -9,6 +10,7 @@
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
+#include <optional>
 #include <string_view>
 
 namespace kernel::filesystem
@@ -59,10 +61,12 @@ namespace kernel::filesystem
     @param parent The parent directory inode.
     @param name The name of the inode to create.
     @param inode_type The type of inode to be created.
+    @param raw_device The device number the new inode should represent.
     @return A pointer to the created inode, or a null pointer if creation failed.
     */
     [[nodiscard]] virtual auto create_inode(kstd::shared_ptr<inode> const & parent, std::string_view name,
-                                            vfs_types::inode_type inode_type)
+                                            vfs_types::inode_type inode_type,
+                                            std::optional<device_number> raw_device = std::nullopt)
         -> kstd::result<kstd::shared_ptr<inode>> = 0;
 
     /**
diff --git a/kernel/kernel/filesystem/inode.cpp b/kernel/kernel/filesystem/inode.cpp
index c1889179..e564ab38 100644
--- a/kernel/kernel/filesystem/inode.cpp
+++ b/kernel/kernel/filesystem/inode.cpp
@@ -12,11 +12,21 @@ namespace kernel::filesystem
     return false;
   }
 
-  auto inode::is_device() const -> bool
+  auto inode::is_block_device() const -> bool
+  {
+    return false;
+  }
+
+  auto inode::is_character_device() const -> bool
   {
     return false;
   }
 
+  auto inode::is_device() const -> bool
+  {
+    return is_block_device() || is_character_device();
+  }
+
   auto inode::is_symbolic_link() const -> bool
   {
     return false;
diff --git a/kernel/kernel/filesystem/inode.hpp b/kernel/kernel/filesystem/inode.hpp
index 67487a8b..005dc57b 100644
--- a/kernel/kernel/filesystem/inode.hpp
+++ b/kernel/kernel/filesystem/inode.hpp
@@ -6,65 +6,61 @@
 
 namespace kernel::filesystem
 {
-  /**
-  @brief Represents an inode in the filesystem.
-  */
+  //! Represents an inode in the filesystem.
   struct inode
   {
-    /**
-    @brief Create an inode.
-    */
+    //! Create an inode.
     inode() = default;
 
-    /**
-    @brief Virtual destructor for the inode.
-    */
+    //! Virtual destructor for the inode.
     virtual ~inode() = default;
 
-    /**
-    @brief Reads from the inode into a @p buffer, starting at the specified @p offset and for a given @p size. This
-    method must be implemented by concrete inode subclasses.
-    @param buffer Destination buffer.
-    @param offset Read offset in bytes.
-    @param size Number of bytes requested.
-    @return Number of bytes read.
-    */
+    //! Read from this inode into a buffer
+    //!
+    //! @param buffer Destination buffer.
+    //! @param offset Read offset in bytes.
+    //! @param size Number of bytes requested.
+    //! @return The number of bytes read on success, an error otherwise.
     virtual auto read(void * buffer, kstd::units::bytes offset, kstd::units::bytes size) const
         -> kstd::result<kstd::units::bytes> = 0;
 
-    /**
-    @brief Writes to the inode into a @p buffer, starting at the specified @p offset and for a given @p size. This
-    method must be implemented by concrete inode subclasses.
-    @param buffer Source buffer.
-    @param offset Write offset in bytes.
-    @param size Number of bytes to write.
-    @return Number of bytes written.
-    */
+    //! Writes data from a buffer into this inode.
+    //!
+    //! @param buffer Source buffer.
+    //! @param offset Write offset in bytes.
+    //! @param size Number of bytes to write.
+    //! @return The number of bytes written on success, an error otherwise.
     virtual auto write(void const * buffer, kstd::units::bytes offset, kstd::units::bytes size)
         -> kstd::result<kstd::units::bytes> = 0;
 
-    /**
-    @brief Returns whether the inode is a directory.
-    @return true if the inode is a directory, false otherwise.
-    */
+    //! Check if this inode is a directory.
+    //!
+    //! @return true iff. this inode is a directory, false otherwise.
     [[nodiscard]] virtual auto is_directory() const -> bool;
 
-    /**
-    @brief Returns whether the inode is a regular file.
-    @return true if the inode is a regular file, false otherwise.
-    */
+    //! Check if this inode is a regular file.
+    //!
+    //! @return true iff. this inode is a regular file, false otherwise.
     [[nodiscard]] virtual auto is_regular() const -> bool;
 
-    /**
-    @brief Returns whether the inode is a device.
-    @return true if the inode is a device, false otherwise.
-    */
-    [[nodiscard]] virtual auto is_device() const -> bool;
+    //! Check if this inode is a block device node.
+    //!
+    //! @return true iff. this inode is a block device node, false otherwise.
+    [[nodiscard]] virtual auto is_block_device() const -> bool;
 
-    /**
-    @brief Returns whether the inode is a symbolic link.
-    @return true if the inode is a symbolic link, false otherwise.
-    */
+    //! Check if this inode is a character device node.
+    //!
+    //! @return true iff. this inode is a character device node, false otherwise.
+    [[nodiscard]] virtual auto is_character_device() const -> bool;
+
+    //! Check if this inode is a device.
+    //!
+    //! @return true iff. this inode is either a block or character device node, false otherwise.
+    [[nodiscard]] auto is_device() const -> bool;
+
+    //! Returns whether the inode is a symbolic link.
+    //!
+    //! @return true iff. this inode is a symbolic link, false otherwise.
     [[nodiscard]] virtual auto is_symbolic_link() const -> bool;
   };
 }  // namespace kernel::filesystem
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.cpp b/kernel/kernel/filesystem/rootfs/filesystem.cpp
index 5ff56547..11c20bc9 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.cpp
@@ -1,5 +1,6 @@
 #include <kernel/filesystem/rootfs/filesystem.hpp>
 
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/inode.hpp>
@@ -11,6 +12,7 @@
 #include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
+#include <optional>
 #include <string_view>
 
 namespace kernel::filesystem::rootfs
@@ -49,7 +51,7 @@ namespace kernel::filesystem::rootfs
   }
 
   auto filesystem::create_inode(kstd::shared_ptr<kernel::filesystem::inode> const &, std::string_view,
-                                kernel::filesystem::vfs_types::inode_type)
+                                vfs_types::inode_type, std::optional<device_number>)
       -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
     return kstd::failure(vfs_errc::read_only_file_system);
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.hpp b/kernel/kernel/filesystem/rootfs/filesystem.hpp
index 498503c5..47e443ef 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.hpp
@@ -1,6 +1,7 @@
 #ifndef TEACH_OS_KERNEL_FILESYSTEM_ROOTFS_FILESYSTEM_HPP
 #define TEACH_OS_KERNEL_FILESYSTEM_ROOTFS_FILESYSTEM_HPP
 
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/inode.hpp>
 #include <kernel/filesystem/vfs_types.hpp>
@@ -11,43 +12,31 @@
 #include <kstd/system_error.hpp>
 #include <kstd/vector.hpp>
 
+#include <optional>
 #include <string_view>
 
 namespace kernel::filesystem::rootfs
 {
-  /**
-  @brief A filesystem for the root filesystem. This filesystem provides access to the root directory and its contents,
-  which are typically populated by the init process during system startup. The rootfs filesystem serves as the top-level
-  directory in the filesystem hierarchy. It is responsible for providing a stable and consistent interface to the root
-  directory.
-  */
+  //! A filesystem for the filesystem root.
+  //!
+  //! This filesystem provides access to the root directory and its contents, which are typically populated by the init
+  //! process during system startup. The rootfs filesystem serves as the top-level directory in the filesystem
+  //! hierarchy. It is responsible for providing a stable and consistent interface to the root directory.
   struct filesystem : kernel::filesystem::filesystem
   {
-    /**
-    @brief Initializes the rootfs filesystem with the given @p backing_inode.
-    @param backing_inode The backing inode to mount (not required by rootfs).
-    @return The result of the mount operation.
-    */
+    //! @copydoc kernel::filesystem::filesystem::mount
     auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode) -> kstd::result<void> override;
 
-    /**
-    @brief Looks up an inode by @p name within a @p parent directory.
-    @param parent The parent directory inode.
-    @param name The name of the inode to look up.
-    @return Always returns nullptr.
-    */
+    //! @copydoc kernel::filesystem::filesystem::lookup.
+    //! @return Always returns an error, as rootfs is always empty.
     [[nodiscard]] auto lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
         -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
 
-    /**
-    @brief Creates a new inode with @p name within a @p parent directory.
-    @param parent The parent directory inode.
-    @param name The name of the inode to create.
-    @param inode_type The type of inode to be created.
-    @return Always returns nullptr, as creating new inodes is not supported in devfs.
-    */
+    //! @copydoc kernel::filesystem::filesystem::create_inode.
+    //! @return Always returns an error, as creating new inodes is not supported in rootfs.
     [[nodiscard]] auto create_inode(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name,
-                                    kernel::filesystem::vfs_types::inode_type inode_type)
+                                    vfs_types::inode_type inode_type,
+                                    std::optional<device_number> raw_device = std::nullopt)
         -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
   };
 }  // namespace kernel::filesystem::rootfs
diff --git a/kernel/kernel/filesystem/vfs.cpp b/kernel/kernel/filesystem/vfs.cpp
index 66faf15a..51c6daba 100644
--- a/kernel/kernel/filesystem/vfs.cpp
+++ b/kernel/kernel/filesystem/vfs.cpp
@@ -3,6 +3,7 @@
 #include <kernel/filesystem/constants.hpp>
 #include <kernel/filesystem/dentry.hpp>
 #include <kernel/filesystem/devfs/filesystem.hpp>
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/mount.hpp>
@@ -185,7 +186,8 @@ namespace kernel::filesystem
     return create_inode(path, vfs_types::inode_type::regular);
   }
 
-  auto vfs::create_inode(std::string_view path, vfs_types::inode_type type) -> kstd::result<void>
+  auto vfs::create_inode(std::string_view path, vfs_types::inode_type type, std::optional<device_number> raw_device)
+      -> kstd::result<void>
   {
     if (!path::is_valid_path(path))
     {
@@ -213,7 +215,7 @@ namespace kernel::filesystem
 
     if (auto fs = mount_context->get_filesystem())
     {
-      if (auto new_inode = fs->create_inode(parent_dentry->get_inode(), name, type))
+      if (auto new_inode = fs->create_inode(parent_dentry->get_inode(), name, type, raw_device))
       {
         auto new_dentry = kstd::make_shared<dentry>(parent_dentry, *new_inode, name);
         parent_dentry->add_child(new_dentry);
diff --git a/kernel/kernel/filesystem/vfs.hpp b/kernel/kernel/filesystem/vfs.hpp
index beb336a4..8f4f11ad 100644
--- a/kernel/kernel/filesystem/vfs.hpp
+++ b/kernel/kernel/filesystem/vfs.hpp
@@ -3,6 +3,7 @@
 
 #include <kernel/filesystem/dentry.hpp>
 #include <kernel/filesystem/devfs/filesystem.hpp>
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/mount.hpp>
 #include <kernel/filesystem/mount_table.hpp>
@@ -12,6 +13,7 @@
 #include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
+#include <optional>
 #include <string_view>
 #include <utility>
 
@@ -116,7 +118,8 @@ namespace kernel::filesystem
 
     auto graft_persistent_device_fs(kstd::shared_ptr<devfs::filesystem> const & device_fs) -> void;
 
-    auto create_inode(std::string_view path, vfs_types::inode_type type) -> kstd::result<void>;
+    auto create_inode(std::string_view path, vfs_types::inode_type type,
+                      std::optional<device_number> raw_device = std::nullopt) -> kstd::result<void>;
 
     mount_table m_mount_table{};
   };
diff --git a/kernel/kernel/filesystem/vfs_types.hpp b/kernel/kernel/filesystem/vfs_types.hpp
index 4c2ed72e..8e3dcd88 100644
--- a/kernel/kernel/filesystem/vfs_types.hpp
+++ b/kernel/kernel/filesystem/vfs_types.hpp
@@ -10,7 +10,8 @@ namespace kernel::filesystem::vfs_types
     directory = 0,
     regular = 1,
     symbolic_link = 2,
-    device = 3
+    block_device = 3,
+    character_device = 4,
   };
 }  // namespace kernel::filesystem::vfs_types
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/filesystem.cpp b/kernel/kernel/test_support/filesystem/filesystem.cpp
index b48c7935..4dd69668 100644
--- a/kernel/kernel/test_support/filesystem/filesystem.cpp
+++ b/kernel/kernel/test_support/filesystem/filesystem.cpp
@@ -1,5 +1,6 @@
 #include <kernel/test_support/filesystem/filesystem.hpp>
 
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/inode.hpp>
 #include <kernel/filesystem/vfs_types.hpp>
 #include <kernel/test_support/filesystem/inode.hpp>
@@ -8,6 +9,7 @@
 #include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
+#include <optional>
 #include <string_view>
 
 namespace kernel::tests::filesystem
@@ -19,7 +21,8 @@ namespace kernel::tests::filesystem
   }
 
   auto filesystem::create_inode(kstd::shared_ptr<kernel::filesystem::inode> const &, std::string_view,
-                                kernel::filesystem::vfs_types::inode_type)
+                                kernel::filesystem::vfs_types::inode_type,
+                                std::optional<kernel::filesystem::device_number>)
       -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
     return kstd::make_shared<inode>();
diff --git a/kernel/kernel/test_support/filesystem/filesystem.hpp b/kernel/kernel/test_support/filesystem/filesystem.hpp
index 17edd079..0f51499e 100644
--- a/kernel/kernel/test_support/filesystem/filesystem.hpp
+++ b/kernel/kernel/test_support/filesystem/filesystem.hpp
@@ -1,6 +1,7 @@
 #ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_FILESYSTEM_HPP
 #define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_FILESYSTEM_HPP
 
+#include <kernel/filesystem/device_number.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/inode.hpp>
 #include <kernel/filesystem/vfs_types.hpp>
@@ -9,6 +10,7 @@
 #include <kstd/result.hpp>
 #include <kstd/system_error.hpp>
 
+#include <optional>
 #include <string_view>
 
 namespace kernel::tests::filesystem
@@ -21,7 +23,8 @@ namespace kernel::tests::filesystem
         -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
 
     [[nodiscard]] auto create_inode(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name,
-                                    kernel::filesystem::vfs_types::inode_type inode_type)
+                                    kernel::filesystem::vfs_types::inode_type inode_type,
+                                    std::optional<kernel::filesystem::device_number> = std::nullopt)
         -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
   };
 }  // namespace kernel::tests::filesystem