kernel/fs: ext2: make block_count take the inode

4 files changed, 16 insertions, 17 deletions

diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index 45d4efeb..a9d75743 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -170,7 +170,7 @@ namespace kernel::filesystem::ext2
     auto const & inode_data = ext2_parent->data();
     auto buffer = kstd::vector<std::byte>{block_size(*mount_state).value};
 
-    for (auto i = 0u; i < block_count(inode_data, *mount_state); ++i)
+    for (auto i = 0u; i < block_count(*ext2_parent, *mount_state); ++i)
     {
       auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data, *mount_state);
       if (!global_block_number)
@@ -299,9 +299,9 @@ namespace kernel::filesystem::ext2
     return kstd::bytes(revision_level(state) == constants::good_old_revision ? 128 : state.superblock.inode_size);
   }
 
-  auto filesystem::block_count(inode_data const & data, mount_state const & state) const -> uint32_t
+  auto filesystem::block_count(inode const & inode, mount_state const & state) const -> uint32_t
   {
-    return data.blocks / (2 << state.superblock.log_block_size);
+    return inode.data().blocks / (2 << state.superblock.log_block_size);
   }
 
   auto filesystem::indirect_levels(mount_state const & state) const -> std::array<indirect_level, 3>
@@ -316,7 +316,7 @@ namespace kernel::filesystem::ext2
   auto filesystem::add_directory_entry(inode & directory, std::string_view name, inode & child, std::uint16_t mode,
                                        mount_state & state) -> kstd::result<void>
   {
-    auto const last_block_index = block_count(directory.data(), state) - 1;
+    auto const last_block_index = block_count(directory, state) - 1;
     auto const global_block = map_inode_block_index_to_global_block_number(last_block_index, directory.data(), state);
 
     if (!global_block)
@@ -378,7 +378,7 @@ namespace kernel::filesystem::ext2
         return kstd::failure(ext2_errc::not_enough_free_blocks);
       }
 
-      auto const new_block_index = block_count(directory.data(), state) - 1;
+      auto const new_block_index = block_count(directory, state) - 1;
       auto const new_global_block =
           map_inode_block_index_to_global_block_number(new_block_index, directory.data(), state);
       if (!new_global_block)
@@ -404,7 +404,7 @@ namespace kernel::filesystem::ext2
       }
     }
 
-    auto size = block_count(directory.data(), state) * block_size(state);
+    auto size = block_count(directory, state) * block_size(state);
     directory.data_mutable().size = size.value;
     return write_inode(directory.number(), directory.data(), state);
   }
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index fec4a283..bb1e8e84 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -121,10 +121,10 @@ namespace kernel::filesystem::ext2
 
     //! Get the number of blocks allocated to an inode.
     //!
-    //! @param data The inode data.
+    //! @param inode The inode whose block count to query.
     //! @param state The driver state to operate on.
     //! @return The number of blocks allocated to the inode.
-    [[nodiscard]] auto block_count(inode_data const & data, mount_state const & state) const -> uint32_t;
+    [[nodiscard]] auto block_count(inode const & inode, mount_state const & state) const -> uint32_t;
 
     //! @}
 
diff --git a/kernel/kernel/filesystem/ext2/inode.cpp b/kernel/kernel/filesystem/ext2/inode.cpp
index a12c65d8..2d4091aa 100644
--- a/kernel/kernel/filesystem/ext2/inode.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.cpp
@@ -136,7 +136,7 @@ namespace kernel::filesystem::ext2
 
     auto block_size = (*filesystem)->block_size(*state);
 
-    auto const current_block_count = (*filesystem)->block_count(m_data, *state);
+    auto const current_block_count = (*filesystem)->block_count(*this, *state);
     auto const max_new_inode_size_without_new_blocks = current_block_count * block_size;
 
     if (new_inode_size > max_new_inode_size_without_new_blocks)
@@ -217,7 +217,7 @@ namespace kernel::filesystem::ext2
 
     for (auto i = 0uz; i < new_blocks->size(); ++i)
     {
-      auto const block_index = (*filesystem)->block_count(m_data, *state) + i;
+      auto const block_index = (*filesystem)->block_count(*this, *state) + i;
       auto const global_block_number = new_blocks->at(i);
 
       if (auto write_result =
diff --git a/kernel/kernel/filesystem/ext2/inode.tests.cpp b/kernel/kernel/filesystem/ext2/inode.tests.cpp
index 0152fd8b..2d3a2ec2 100644
--- a/kernel/kernel/filesystem/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.tests.cpp
@@ -353,24 +353,23 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
 
     THEN("writing allocates new blocks and updates the inode size")
     {
-      auto inode_data = static_cast<kernel::filesystem::ext2::inode *>(file.value().get())->data();
+      auto inode = static_pointer_cast<kernel::filesystem::ext2::inode>(file.value());
 
       auto const block_size = fs->block_size(*mount_state);
-      auto const expected_allocated_blocks = 32 * fs->block_count(inode_data, *mount_state);
+      auto const expected_allocated_blocks = 32 * fs->block_count(*inode, *mount_state);
 
       auto write_buffer = kstd::vector<std::byte>(block_size.value * expected_allocated_blocks, std::byte{'A'});
 
-      auto const bytes_written = file.value()->write(write_buffer, 0_B);
+      auto const bytes_written = inode->write(write_buffer, 0_B);
       REQUIRE(bytes_written == block_size * expected_allocated_blocks);
 
       auto read_buffer = kstd::vector<std::byte>(block_size.value * expected_allocated_blocks, std::byte{0x00});
-      auto const bytes_read = file.value()->read(read_buffer, 0_B);
+      auto const bytes_read = inode->read(read_buffer, 0_B);
       REQUIRE(bytes_read == block_size * expected_allocated_blocks);
       REQUIRE(std::ranges::all_of(read_buffer, [](std::byte c) { return c == std::byte{'A'}; }));
 
-      auto new_inode_data = static_cast<kernel::filesystem::ext2::inode *>(file.value().get())->data();
-      REQUIRE(new_inode_data.size == write_buffer.size());
-      REQUIRE(fs->block_count(new_inode_data, *mount_state) == expected_allocated_blocks);
+      REQUIRE(inode->size().value == write_buffer.size());
+      REQUIRE(fs->block_count(*inode, *mount_state) == expected_allocated_blocks);
     }
 
     THEN("writing to a an inode of type directory panics")