kernel/fs: thread driver data through public API

15 files changed, 85 insertions, 56 deletions

diff --git a/kernel/kernel/filesystem/devfs/filesystem.cpp b/kernel/kernel/filesystem/devfs/filesystem.cpp
index cc42a5bd..3e94f2ac 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.cpp
@@ -64,7 +64,8 @@ namespace kernel::filesystem::devfs
     return mount_result{m_root_inode, nullptr};
   }
 
-  auto filesystem::lookup(inode_ptr const & parent, std::string_view name) const -> kstd::result<inode_ptr>
+  auto filesystem::lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr) const
+      -> kstd::result<inode_ptr>
   {
     if (!parent)
     {
@@ -90,7 +91,7 @@ namespace kernel::filesystem::devfs
     return kstd::failure(vfs_errc::no_such_file_or_directory);
   }
 
-  auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type,
+  auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type, driver_data_ptr,
                                 std::optional<kapi::filesystem::device_number>) -> kstd::result<inode_ptr>
   {
     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 f176a367..12ac7e83 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.hpp
@@ -32,12 +32,13 @@ namespace kernel::filesystem::devfs
   {
     auto mount(inode_ptr const & backing_inode) -> kstd::result<mount_result> override;
 
-    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name) const
-        -> kstd::result<inode_ptr> override;
+    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name,
+                              driver_data_ptr driver_data = nullptr) const -> kstd::result<inode_ptr> override;
 
     //! @copydoc kernel::filesystem::filesystem::create_inode
     //! @return Always returns an error, as creating new inodes is not supported in devfs.
     [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
+                                    driver_data_ptr driver_data = nullptr,
                                     std::optional<kapi::filesystem::device_number> raw_device = std::nullopt)
         -> kstd::result<inode_ptr> override;
 
diff --git a/kernel/kernel/filesystem/error.cpp b/kernel/kernel/filesystem/error.cpp
index d288693e..0d6ae01e 100644
--- a/kernel/kernel/filesystem/error.cpp
+++ b/kernel/kernel/filesystem/error.cpp
@@ -56,6 +56,8 @@ namespace kernel::filesystem
             return "invalid argument";
           case vfs_errc::not_mounted:
             return "filesystem is not mounted";
+          case vfs_errc::invalid_driver_data:
+            return "invalid driver data";
           default:
             return "unknown VFS error";
         }
@@ -69,6 +71,7 @@ namespace kernel::filesystem
           case vfs_errc::invalid_filesystem:
           case vfs_errc::invalid_inode:
           case vfs_errc::invalid_argument:
+          case vfs_errc::invalid_driver_data:
             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 41009bb7..6b167355 100644
--- a/kernel/kernel/filesystem/error.hpp
+++ b/kernel/kernel/filesystem/error.hpp
@@ -28,6 +28,7 @@ namespace kernel::filesystem
     no_such_device,
     invalid_argument,
     not_mounted,
+    invalid_driver_data,
   };
 
   [[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 a0a0dbf1..9275f5a9 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -62,7 +62,7 @@ namespace kernel::filesystem::ext2
       return "ext2";
     }
 
-    [[nodiscard]] auto probe(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode) const noexcept
+    [[nodiscard]] auto probe(filesystem::inode_ptr const & backing_inode) const noexcept
         -> kstd::result<std::uint32_t> override
     {
       auto superblock = ext2::superblock{};
@@ -88,7 +88,7 @@ namespace kernel::filesystem::ext2
       return 0;
     }
 
-    [[nodiscard]] auto make_instance() const -> kstd::shared_ptr<kernel::filesystem::filesystem> override
+    [[nodiscard]] auto make_instance() const -> filesystem::filesystem_ptr override
     {
       return kstd::make_shared<filesystem>();
     }
@@ -106,8 +106,7 @@ namespace kernel::filesystem::ext2
     };
   }
 
-  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode)
-      -> kstd::result<mount_result>
+  auto filesystem::mount(inode_ptr const & backing_inode) -> kstd::result<mount_result>
   {
     m_backing_inode = backing_inode;
 
@@ -151,8 +150,8 @@ namespace kernel::filesystem::ext2
                         kstd::make_shared<mount_state>(m_superblock, m_block_group_descriptors, m_backing_inode)};
   }
 
-  auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
-      -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
+  auto filesystem::lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) const
+      -> kstd::result<inode_ptr>
   {
     if (!parent)
     {
@@ -164,6 +163,12 @@ namespace kernel::filesystem::ext2
       return kstd::failure(vfs_errc::not_a_directory);
     }
 
+    auto mount_state = static_pointer_cast<struct mount_state>(driver_data);
+    if (!mount_state)
+    {
+      return kstd::failure(vfs_errc::invalid_driver_data);
+    }
+
     auto * ext2_parent = static_cast<inode *>(parent.get());
     auto const & inode_data = ext2_parent->data();
     kstd::vector<uint8_t> buffer(block_size().value);
@@ -200,9 +205,8 @@ namespace kernel::filesystem::ext2
     return kstd::failure(vfs_errc::no_such_file_or_directory);
   }
 
-  auto filesystem::create_inode(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name,
-                                kapi::filesystem::file_type type,
-                                std::optional<kapi::filesystem::device_number> raw_device)
+  auto filesystem::create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
+                                driver_data_ptr driver_data, std::optional<kapi::filesystem::device_number> raw_device)
       -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
   {
     if (!parent)
@@ -216,7 +220,6 @@ namespace kernel::filesystem::ext2
     }
 
     auto is_device = kapi::filesystem::is_device(type);
-
     if (is_device && !raw_device)
     {
       return kstd::failure(vfs_errc::invalid_argument);
@@ -228,6 +231,12 @@ namespace kernel::filesystem::ext2
       return kstd::failure(vfs_errc::invalid_argument);
     }
 
+    auto mount_state = static_pointer_cast<struct mount_state>(driver_data);
+    if (!mount_state)
+    {
+      return kstd::failure(vfs_errc::invalid_driver_data);
+    }
+
     auto maybe_inode_number = allocate_inode();
     if (!maybe_inode_number)
     {
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index 1f7fe8af..c6f8b04a 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -77,10 +77,11 @@ namespace kernel::filesystem::ext2
   {
     auto mount(inode_ptr const & backing_inode) -> kstd::result<mount_result> override;
 
-    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name) const
+    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) const
         -> kstd::result<inode_ptr> override;
 
     [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
+                                    driver_data_ptr driver_data,
                                     std::optional<kapi::filesystem::device_number> raw_device = std::nullopt)
         -> kstd::result<inode_ptr> override;
 
diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
index 708f83df..0b815584 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
@@ -51,6 +51,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
     auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
+    auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
 
     THEN("the root inode is available and is a directory")
@@ -61,26 +62,26 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
 
     THEN("lookup resolves known entries from the image")
     {
-      auto information = fs->lookup(root, "information");
+      auto information = fs->lookup(root, "information", driver_data);
       REQUIRE(information);
       REQUIRE(information.value()->is_directory());
 
-      auto info_1 = fs->lookup(*information, "info_1.txt");
+      auto info_1 = fs->lookup(*information, "info_1.txt", driver_data);
       REQUIRE(info_1);
       REQUIRE(info_1.value()->is_regular());
     }
 
     THEN("lookup returns null for invalid inputs")
     {
-      REQUIRE(!fs->lookup(nullptr, "information"));
+      REQUIRE(!fs->lookup(nullptr, "information", driver_data));
 
-      auto information = fs->lookup(root, "information");
+      auto information = fs->lookup(root, "information", driver_data);
       REQUIRE(information);
-      auto info_1 = fs->lookup(*information, "info_1.txt");
+      auto info_1 = fs->lookup(*information, "info_1.txt", driver_data);
       REQUIRE(info_1);
 
-      REQUIRE(!fs->lookup(*info_1, "anything"));
-      REQUIRE(!fs->lookup(root, "does_not_exist"));
+      REQUIRE(!fs->lookup(*info_1, "anything", driver_data));
+      REQUIRE(!fs->lookup(root, "does_not_exist", driver_data));
     }
   }
 }
@@ -103,50 +104,52 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
     auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
+    auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
 
     THEN("a file can be created")
     {
-      auto lookup_result = fs->lookup(root, "blub");
+      auto lookup_result = fs->lookup(root, "blub", driver_data);
       REQUIRE(!lookup_result);
 
-      auto new_inode = fs->create_inode(root, "blub", kapi::filesystem::file_type::regular);
+      auto new_inode = fs->create_inode(root, "blub", kapi::filesystem::file_type::regular, driver_data);
       REQUIRE(new_inode);
       REQUIRE(new_inode.value()->is_regular());
 
-      lookup_result = fs->lookup(root, "blub");
+      lookup_result = fs->lookup(root, "blub", driver_data);
       REQUIRE(lookup_result);
     }
 
     THEN("a directory can be created")
     {
-      auto lookup_result = fs->lookup(root, "blub");
+      auto lookup_result = fs->lookup(root, "blub", driver_data);
       REQUIRE(!lookup_result);
 
-      auto new_directory = fs->create_inode(root, "blub", kapi::filesystem::file_type::directory);
+      auto new_directory = fs->create_inode(root, "blub", kapi::filesystem::file_type::directory, driver_data);
       REQUIRE(new_directory);
       REQUIRE(new_directory.value()->is_directory());
 
-      lookup_result = fs->lookup(root, "blub");
+      lookup_result = fs->lookup(root, "blub", driver_data);
       REQUIRE(lookup_result);
     }
 
     THEN("a directory and a file within can be created")
     {
-      auto new_directory = fs->create_inode(root, "blub", kapi::filesystem::file_type::directory);
+      auto new_directory = fs->create_inode(root, "blub", kapi::filesystem::file_type::directory, driver_data);
       REQUIRE(new_directory);
 
-      auto new_file = fs->create_inode(new_directory.value(), "blub_file", kapi::filesystem::file_type::regular);
+      auto new_file =
+          fs->create_inode(new_directory.value(), "blub_file", kapi::filesystem::file_type::regular, driver_data);
       REQUIRE(new_file);
 
-      auto lookup_result = fs->lookup(new_directory.value(), "blub_file");
+      auto lookup_result = fs->lookup(new_directory.value(), "blub_file", driver_data);
       REQUIRE(lookup_result);
       REQUIRE(lookup_result.value()->is_regular());
     }
 
     THEN("a file can be created and written to")
     {
-      auto new_inode = fs->create_inode(root, "blub", kapi::filesystem::file_type::regular);
+      auto new_inode = fs->create_inode(root, "blub", kapi::filesystem::file_type::regular, driver_data);
       REQUIRE(new_inode);
 
       auto buffer =
@@ -165,7 +168,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
 
     THEN("a symbolic link is not implemented yet")
     {
-      REQUIRE_THROWS_AS(fs->create_inode(root, "blub", kapi::filesystem::file_type::symbolic_link),
+      REQUIRE_THROWS_AS(fs->create_inode(root, "blub", kapi::filesystem::file_type::symbolic_link, driver_data),
                         kernel::tests::cpu::halt);
     }
   }
diff --git a/kernel/kernel/filesystem/ext2/inode.tests.cpp b/kernel/kernel/filesystem/ext2/inode.tests.cpp
index 9a602a28..356e44ed 100644
--- a/kernel/kernel/filesystem/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.tests.cpp
@@ -104,11 +104,12 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
     auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
     auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
+    auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
 
-    auto information = fs->lookup(root, "information");
+    auto information = fs->lookup(root, "information", driver_data);
     REQUIRE(information);
-    auto file = fs->lookup(*information, "info_1.txt");
+    auto file = fs->lookup(*information, "info_1.txt", driver_data);
     REQUIRE(file);
     REQUIRE(file.value()->is_regular());
 
@@ -314,11 +315,12 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
     auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
     auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
+    auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
 
-    auto information = fs->lookup(root, "information");
+    auto information = fs->lookup(root, "information", driver_data);
     REQUIRE(information);
-    auto file = fs->lookup(*information, "info_1.txt");
+    auto file = fs->lookup(*information, "info_1.txt", driver_data);
     REQUIRE(file);
     REQUIRE(file.value()->is_regular());
 
diff --git a/kernel/kernel/filesystem/filesystem.hpp b/kernel/kernel/filesystem/filesystem.hpp
index f1b39bd4..2e713c89 100644
--- a/kernel/kernel/filesystem/filesystem.hpp
+++ b/kernel/kernel/filesystem/filesystem.hpp
@@ -52,19 +52,21 @@ namespace kernel::filesystem
     //!
     //! @param parent The parent inode.
     //! @param name The name of the child inode to look up.
+    //! @param driver_data The per-mount data used by the driver.
     //! @return A pointer to the requested child inode on success, an error otherwise.
-    [[nodiscard]] virtual auto lookup(inode_ptr const & parent, std::string_view name) const
-        -> kstd::result<inode_ptr> = 0;
+    [[nodiscard]] virtual auto lookup(inode_ptr const & parent, std::string_view name,
+                                      driver_data_ptr driver_data) const -> kstd::result<inode_ptr> = 0;
 
     //! Create a new inode with the given name below a given parent inode.
     //!
     //! @param parent The parent inode.
     //! @param name The name of the inode to create.
     //! @param type The file type of inode to be created.
+    //! @param driver_data The per-mount data used by the driver.
     //! @param raw_device The device number the new inode should represent, if any.
     //! @return A pointer to the created inode on success, an error otherwise.
     [[nodiscard]] virtual auto create_inode(inode_ptr const & parent, std::string_view name,
-                                            kapi::filesystem::file_type type,
+                                            kapi::filesystem::file_type type, driver_data_ptr driver_data,
                                             std::optional<kapi::filesystem::device_number> raw_device = std::nullopt)
         -> kstd::result<kstd::shared_ptr<inode>> = 0;
   };
diff --git a/kernel/kernel/filesystem/mount.cpp b/kernel/kernel/filesystem/mount.cpp
index d808ff52..616a9dbd 100644
--- a/kernel/kernel/filesystem/mount.cpp
+++ b/kernel/kernel/filesystem/mount.cpp
@@ -109,6 +109,11 @@ namespace kernel::filesystem
     return m_source_mount.lock();
   }
 
+  auto mount::driver_data() const -> kstd::shared_ptr<void>
+  {
+    return m_driver_data;
+  }
+
   auto mount::increment_ref_count() -> void
   {
     m_ref_count += 1;
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.cpp b/kernel/kernel/filesystem/rootfs/filesystem.cpp
index 147d967a..994ebaca 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.cpp
@@ -50,12 +50,12 @@ namespace kernel::filesystem::rootfs
     return mount_result{root, nullptr};
   }
 
-  auto filesystem::lookup(inode_ptr const &, std::string_view) const -> kstd::result<inode_ptr>
+  auto filesystem::lookup(inode_ptr const &, std::string_view, driver_data_ptr) const -> kstd::result<inode_ptr>
   {
     return kstd::failure(vfs_errc::no_such_file_or_directory);
   }
 
-  auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type,
+  auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type, driver_data_ptr,
                                 std::optional<kapi::filesystem::device_number>) -> kstd::result<inode_ptr>
   {
     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 5a72ff42..77dc9c46 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.hpp
@@ -29,12 +29,13 @@ namespace kernel::filesystem::rootfs
 
     //! @copydoc kernel::filesystem::filesystem::lookup.
     //! @return Always returns an error, as rootfs is always empty.
-    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name) const
-        -> kstd::result<inode_ptr> override;
+    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name,
+                              driver_data_ptr driver_data = nullptr) const -> kstd::result<inode_ptr> override;
 
     //! @copydoc kernel::filesystem::filesystem::create_inode.
     //! @return Always returns an error, as creating new inodes is not supported in rootfs.
     [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
+                                    driver_data_ptr driver_data = nullptr,
                                     std::optional<kapi::filesystem::device_number> raw_device = std::nullopt)
         -> kstd::result<inode_ptr> override;
   };
diff --git a/kernel/kernel/filesystem/vfs.cpp b/kernel/kernel/filesystem/vfs.cpp
index 6a15d211..512b7394 100644
--- a/kernel/kernel/filesystem/vfs.cpp
+++ b/kernel/kernel/filesystem/vfs.cpp
@@ -296,7 +296,8 @@ namespace kernel::filesystem
 
     if (auto fs = mount_context->filesystem())
     {
-      if (auto new_inode = fs->create_inode(parent_dentry->inode(), name, type, raw_device))
+      if (auto new_inode =
+              fs->create_inode(parent_dentry->inode(), name, type, mount_context->driver_data(), raw_device))
       {
         (*new_inode)->set_owning_mount(mount_context);
 
@@ -390,7 +391,7 @@ namespace kernel::filesystem
       if (!next_dentry)
       {
         auto current_fs = current_mount->filesystem();
-        auto found_inode = current_fs->lookup(current_dentry->inode(), part);
+        auto found_inode = current_fs->lookup(current_dentry->inode(), part, current_mount->driver_data());
         if (!found_inode)
         {
           return kstd::failure(found_inode.error());
diff --git a/kernel/kernel/test_support/filesystem/filesystem.cpp b/kernel/kernel/test_support/filesystem/filesystem.cpp
index 8bd46e3c..105746e8 100644
--- a/kernel/kernel/test_support/filesystem/filesystem.cpp
+++ b/kernel/kernel/test_support/filesystem/filesystem.cpp
@@ -15,20 +15,18 @@
 
 namespace kernel::tests::filesystem
 {
-  auto filesystem::mount(kstd::shared_ptr<kernel::filesystem::inode> const &) -> kstd::result<mount_result>
+  auto filesystem::mount(inode_ptr const &) -> kstd::result<mount_result>
   {
     return std::pair{kstd::make_shared<inode>(), nullptr};
   }
 
-  auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const &, std::string_view) const
-      -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
+  auto filesystem::lookup(inode_ptr const &, std::string_view, driver_data_ptr) const -> kstd::result<inode_ptr>
   {
     return kstd::make_shared<inode>();
   }
 
-  auto filesystem::create_inode(kstd::shared_ptr<kernel::filesystem::inode> const &, std::string_view,
-                                kapi::filesystem::file_type, std::optional<kapi::filesystem::device_number>)
-      -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
+  auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type, driver_data_ptr,
+                                std::optional<kapi::filesystem::device_number>) -> kstd::result<inode_ptr>
   {
     return kstd::make_shared<inode>();
   }
diff --git a/kernel/kernel/test_support/filesystem/filesystem.hpp b/kernel/kernel/test_support/filesystem/filesystem.hpp
index d7f64883..52111a5a 100644
--- a/kernel/kernel/test_support/filesystem/filesystem.hpp
+++ b/kernel/kernel/test_support/filesystem/filesystem.hpp
@@ -22,13 +22,14 @@ namespace kernel::tests::filesystem
     auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode)
         -> kstd::result<mount_result> override;
 
-    [[nodiscard]] auto lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
+    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name,
+                              driver_data_ptr driver_data = nullptr) const
         -> 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,
-                                    kapi::filesystem::file_type type,
+    [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
+                                    driver_data_ptr driver_data = nullptr,
                                     std::optional<kapi::filesystem::device_number> = std::nullopt)
-        -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
+        -> kstd::result<inode_ptr> override;
   };
 }  // namespace kernel::tests::filesystem