kernel/fs: post-refactor cleanup

7 files changed, 54 insertions, 78 deletions

diff --git a/kernel/kernel/filesystem/devfs/filesystem.hpp b/kernel/kernel/filesystem/devfs/filesystem.hpp
index 12ac7e83..7529cd28 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.hpp
@@ -32,13 +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,
-                              driver_data_ptr driver_data = nullptr) const -> kstd::result<inode_ptr> override;
+    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) 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,
+                                    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/devfs/filesystem.tests.cpp b/kernel/kernel/filesystem/devfs/filesystem.tests.cpp
index 20523b71..ec0c1144 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.tests.cpp
@@ -25,23 +25,21 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     setup_modules(1);
 
     auto fs = kstd::make_shared<kernel::filesystem::devfs::filesystem>();
-    auto root = fs->mount(nullptr);
-
-    THEN("mount succeeds")
-    {
-      REQUIRE(root);
-    }
+    auto mount = fs->mount(nullptr);
+    REQUIRE(mount);
+    auto [root, driver_data] = *mount;
+    REQUIRE(root);
 
     THEN("lookup on root finds ram0 device inode")
     {
-      auto inode = fs->lookup(root->first, "ram0");
+      auto inode = fs->lookup(root, "ram0", driver_data);
       REQUIRE(inode);
       REQUIRE(inode.value()->is_device());
     }
 
     THEN("lookup of an unknown device returns error")
     {
-      auto inode = fs->lookup(root->first, "ram99");
+      auto inode = fs->lookup(root, "ram99", driver_data);
       REQUIRE(!inode);
     }
 
@@ -51,23 +49,23 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
       auto other_root = other_fs->mount(nullptr);
       CHECK(other_root);
 
-      auto inode = fs->lookup(other_root->first, "ram0");
+      auto inode = fs->lookup(other_root->first, "ram0", driver_data);
       REQUIRE(!inode);
     }
 
     THEN("lookup with a non-directory parent returns error")
     {
-      auto non_directory_inode = fs->lookup(root->first, "ram0");
+      auto non_directory_inode = fs->lookup(root, "ram0", driver_data);
       REQUIRE(non_directory_inode);
       REQUIRE_FALSE(non_directory_inode.value()->is_directory());
 
-      auto result = fs->lookup(*non_directory_inode, "anything");
+      auto result = fs->lookup(*non_directory_inode, "anything", driver_data);
       REQUIRE(!result);
     }
 
     THEN("create_inode always returns an error")
     {
-      auto result = fs->create_inode(root->first, "new_device", kapi::filesystem::file_type::regular);
+      auto result = fs->create_inode(root, "new_device", kapi::filesystem::file_type::regular, driver_data);
       REQUIRE(!result);
     }
   }
@@ -77,14 +75,16 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     setup_modules(3, 2048);
 
     auto fs = kstd::make_shared<kernel::filesystem::devfs::filesystem>();
-    auto root = fs->mount(nullptr);
+    auto mount = fs->mount(nullptr);
+    REQUIRE(mount);
+    auto [root, driver_data] = *mount;
     REQUIRE(root);
 
     THEN("lookup finds all generated RAM devices")
     {
-      REQUIRE(fs->lookup(root->first, "ram0"));
-      REQUIRE(fs->lookup(root->first, "ram1"));
-      REQUIRE(fs->lookup(root->first, "ram2"));
+      REQUIRE(fs->lookup(root, "ram0", driver_data));
+      REQUIRE(fs->lookup(root, "ram1", driver_data));
+      REQUIRE(fs->lookup(root, "ram2", driver_data));
     }
   }
 }
@@ -94,13 +94,15 @@ SCENARIO("Devfs filesystem updates", "[filesystem][devfs]")
   GIVEN("A mounted devfs, and a bus attached to the root without a device attached")
   {
     auto fs = kstd::make_shared<kernel::filesystem::devfs::filesystem>();
-    auto root = fs->mount(nullptr);
+    auto mount = fs->mount(nullptr);
+    REQUIRE(mount);
+    auto [root, driver_data] = *mount;
     REQUIRE(root);
 
     auto bus = kstd::make_shared<kapi::devices::bus>("devfs_live_update_bus");
     kapi::devices::get_root_bus()->add_child(bus);
 
-    REQUIRE_FALSE(fs->lookup(root->first, "devfs_live_update_device_node"));
+    REQUIRE_FALSE(fs->lookup(root, "devfs_live_update_device_node", driver_data));
 
     WHEN("a device is attached, bound, and published")
     {
@@ -113,7 +115,7 @@ SCENARIO("Devfs filesystem updates", "[filesystem][devfs]")
 
       THEN("devfs finds it immediately")
       {
-        REQUIRE(fs->lookup(root->first, "devfs_live_update_device_node"));
+        REQUIRE(fs->lookup(root, "devfs_live_update_device_node", driver_data));
       }
 
       WHEN("the device is detached")
@@ -122,7 +124,7 @@ SCENARIO("Devfs filesystem updates", "[filesystem][devfs]")
 
         THEN("devfs does not find it anymore")
         {
-          REQUIRE_FALSE(fs->lookup(root->first, "devfs_live_update_device_node"));
+          REQUIRE_FALSE(fs->lookup(root, "devfs_live_update_device_node", driver_data));
         }
       }
     }
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index ef7afdfb..9ee737a7 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -165,11 +165,6 @@ namespace kernel::filesystem::ext2
                                                         uint32_t global_block_number, mount_state & state)
         -> kstd::result<void>;
 
-    //! Get the backing inode of the file system.
-    //!
-    //! @return A reference to the backing inode.
-    [[nodiscard]] auto backing_inode() const -> inode_ptr const &;
-
   private:
     struct indirect_level
     {
diff --git a/kernel/kernel/filesystem/ext2/inode.cpp b/kernel/kernel/filesystem/ext2/inode.cpp
index 561bf9de..8c7d0ec0 100644
--- a/kernel/kernel/filesystem/ext2/inode.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.cpp
@@ -52,9 +52,14 @@ namespace kernel::filesystem::ext2
     {
       return kstd::failure(driver_data.error());
     }
-
     auto state = static_pointer_cast<mount_state const>(*driver_data);
 
+    auto backing_inode = state->backing_inode;
+    if (!state->backing_inode)
+    {
+      return kstd::failure(vfs_errc::not_mounted);
+    }
+
     auto block_size = (*filesystem)->block_size(*state);
     auto block_index = offset / block_size;
     auto in_block_offset = offset % block_size;
@@ -78,16 +83,11 @@ namespace kernel::filesystem::ext2
       }
       else
       {
-        auto inode = backing_inode();
-        if (!inode)
-        {
-          return kstd::failure(inode.error());
-        }
-
         auto const block_start_offset = block_number.value() * block_size;
         auto const read_offset = block_start_offset + in_block_offset;
 
-        auto const read_result = (*inode)->read(buffer.subspan(bytes_read.value, bytes_to_read.value), read_offset);
+        auto const read_result =
+            backing_inode->read(buffer.subspan(bytes_read.value, bytes_to_read.value), read_offset);
         if (!read_result)
         {
           return kstd::failure(read_result.error());
@@ -126,8 +126,14 @@ namespace kernel::filesystem::ext2
     {
       return kstd::failure(driver_data.error());
     }
-
     auto state = static_pointer_cast<mount_state>(*driver_data);
+
+    auto backing_inode = state->backing_inode;
+    if (!state->backing_inode)
+    {
+      return kstd::failure(vfs_errc::not_mounted);
+    }
+
     auto block_size = (*filesystem)->block_size(*state);
 
     auto const current_block_count = (*filesystem)->inode_block_count(m_data, *state);
@@ -165,14 +171,8 @@ namespace kernel::filesystem::ext2
       auto const block_start_offset = block_number.value() * block_size;
       auto const write_offset = block_start_offset + in_block_offset;
 
-      auto inode = backing_inode();
-      if (!inode)
-      {
-        return kstd::failure(inode.error());
-      }
-
       auto const write_result =
-          (*inode)->write(buffer.subspan(bytes_written.value, bytes_to_write.value), write_offset);
+          backing_inode->write(buffer.subspan(bytes_written.value, bytes_to_write.value), write_offset);
       if (!write_result)
       {
         return kstd::failure(write_result.error());
@@ -373,26 +373,6 @@ namespace kernel::filesystem::ext2
     return kstd::failure(vfs_errc::not_mounted);
   }
 
-  auto inode::backing_inode() -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
-  {
-    if (auto mount = owning_mount().lock())
-    {
-      return mount->backing_inode();
-    }
-
-    return kstd::failure(vfs_errc::not_mounted);
-  }
-
-  auto inode::backing_inode() const -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode const>>
-  {
-    if (auto mount = owning_mount().lock())
-    {
-      return mount->backing_inode();
-    }
-
-    return kstd::failure(vfs_errc::not_mounted);
-  }
-
   auto inode::get_driver_data() -> kstd::result<kstd::shared_ptr<void>>
   {
     if (auto mount = owning_mount().lock())
diff --git a/kernel/kernel/filesystem/ext2/inode.hpp b/kernel/kernel/filesystem/ext2/inode.hpp
index 6ca2f1b5..7f668833 100644
--- a/kernel/kernel/filesystem/ext2/inode.hpp
+++ b/kernel/kernel/filesystem/ext2/inode.hpp
@@ -105,10 +105,6 @@ namespace kernel::filesystem::ext2
 
     [[nodiscard]] auto get_filesystem() const -> kstd::result<kstd::shared_ptr<filesystem const>>;
 
-    [[nodiscard]] auto backing_inode() -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>;
-
-    [[nodiscard]] auto backing_inode() const -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode const>>;
-
     [[nodiscard]] auto get_driver_data() -> kstd::result<kstd::shared_ptr<void>>;
 
     [[nodiscard]] auto get_driver_data() const -> kstd::result<kstd::shared_ptr<void const>>;
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.hpp b/kernel/kernel/filesystem/rootfs/filesystem.hpp
index 77dc9c46..edef76d4 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.hpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.hpp
@@ -29,13 +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,
-                              driver_data_ptr driver_data = nullptr) const -> kstd::result<inode_ptr> override;
+    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) 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,
+                                    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/rootfs/filesystem.tests.cpp b/kernel/kernel/filesystem/rootfs/filesystem.tests.cpp
index b4297582..15c8e313 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.tests.cpp
@@ -14,31 +14,34 @@ SCENARIO("Rootfs filesystem mount and lookup", "[filesystem][rootfs][filesystem]
 {
   GIVEN("a mounted rootfs filesystem")
   {
-    auto fs = kernel::filesystem::rootfs::filesystem{};
-    auto root = fs.mount(nullptr);
+    auto fs = kstd::make_shared<kernel::filesystem::rootfs::filesystem>();
+    auto mount = fs->mount(nullptr);
+    REQUIRE(mount);
+    auto [root, driver_data] = *mount;
+    REQUIRE(root);
 
     THEN("the filesystem can be mounted successfully")
     {
-      REQUIRE(root);
+      REQUIRE(mount);
     }
 
     THEN("looking up a non-existent directory returns an error")
     {
-      auto non_existent_inode_1 = fs.lookup(root->first, "");
+      auto non_existent_inode_1 = fs->lookup(root, "", driver_data);
       REQUIRE(!non_existent_inode_1);
-      auto non_existent_inode_2 = fs.lookup(root->first, "nonexistent");
+      auto non_existent_inode_2 = fs->lookup(root, "nonexistent", driver_data);
       REQUIRE(!non_existent_inode_2);
     }
 
     THEN("looking up with a null parent inode returns an error")
     {
-      auto result = fs.lookup(nullptr, "dev");
+      auto result = fs->lookup(nullptr, "dev", driver_data);
       REQUIRE(!result);
     }
 
     THEN("create_inode always returns an error")
     {
-      auto result = fs.create_inode(root->first, "new_device", kapi::filesystem::file_type::directory);
+      auto result = fs->create_inode(root, "new_device", kapi::filesystem::file_type::directory, driver_data);
       REQUIRE(!result);
     }
   }