1 files changed, 86 insertions, 22 deletions

diff --git a/kernel/kernel/filesystem/ext2/inode.cpp b/kernel/kernel/filesystem/ext2/inode.cpp
index b04be99a..561bf9de 100644
--- a/kernel/kernel/filesystem/ext2/inode.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.cpp
@@ -2,6 +2,7 @@
 
 #include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/ext2/filesystem.hpp>
+#include <kernel/filesystem/ext2/mount_state.hpp>
 #include <kernel/filesystem/inode.hpp>
 #include <kernel/filesystem/mount.hpp>
 
@@ -46,20 +47,30 @@ namespace kernel::filesystem::ext2
       return kstd::failure(filesystem.error());
     }
 
-    auto block_index = offset / (*filesystem)->block_size();
-    auto in_block_offset = offset % (*filesystem)->block_size();
+    auto driver_data = get_driver_data();
+    if (!driver_data)
+    {
+      return kstd::failure(driver_data.error());
+    }
+
+    auto state = static_pointer_cast<mount_state const>(*driver_data);
+
+    auto block_size = (*filesystem)->block_size(*state);
+    auto block_index = offset / block_size;
+    auto in_block_offset = offset % block_size;
 
     auto bytes_read = 0_B;
 
     while (bytes_read < requested_size)
     {
-      auto const block_number = (*filesystem)->map_inode_block_index_to_global_block_number(block_index, m_data);
+      auto const block_number =
+          (*filesystem)->map_inode_block_index_to_global_block_number(block_index, m_data, *state);
       if (!block_number)
       {
         break;
       }
 
-      auto const bytes_to_read = std::min(requested_size - bytes_read, (*filesystem)->block_size() - in_block_offset);
+      auto const bytes_to_read = std::min(requested_size - bytes_read, block_size - in_block_offset);
       if (block_number == 0)
       {
         kstd::libc::memset(buffer.data() + bytes_read, 0, bytes_to_read.value);
@@ -73,7 +84,7 @@ namespace kernel::filesystem::ext2
           return kstd::failure(inode.error());
         }
 
-        auto const block_start_offset = block_number.value() * (*filesystem)->block_size();
+        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);
@@ -110,14 +121,22 @@ namespace kernel::filesystem::ext2
       return kstd::failure(filesystem.error());
     }
 
-    auto const current_block_count = (*filesystem)->inode_block_count(m_data);
-    auto const max_new_inode_size_without_new_blocks = current_block_count * (*filesystem)->block_size();
+    auto driver_data = get_driver_data();
+    if (!driver_data)
+    {
+      return kstd::failure(driver_data.error());
+    }
+
+    auto state = static_pointer_cast<mount_state>(*driver_data);
+    auto block_size = (*filesystem)->block_size(*state);
+
+    auto const current_block_count = (*filesystem)->inode_block_count(m_data, *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)
     {
       auto const additional_blocks_needed =
-          (new_inode_size - max_new_inode_size_without_new_blocks + (*filesystem)->block_size() - 1_B) /
-          (*filesystem)->block_size();
+          (new_inode_size - max_new_inode_size_without_new_blocks + block_size - 1_B) / block_size;
 
       if (!append_blocks(additional_blocks_needed))
       {
@@ -126,24 +145,24 @@ namespace kernel::filesystem::ext2
       }
     }
 
-    auto block_index = offset / (*filesystem)->block_size();
-    auto in_block_offset = offset % (*filesystem)->block_size();
+    auto block_index = offset / block_size;
+    auto in_block_offset = offset % block_size;
 
     auto bytes_written = 0_B;
 
     while (bytes_written < kstd::bytes{buffer.size()})
     {
-      auto const block_number = (*filesystem)->map_inode_block_index_to_global_block_number(block_index, m_data);
+      auto const block_number =
+          (*filesystem)->map_inode_block_index_to_global_block_number(block_index, m_data, *state);
       // TODO BA-FS26 if blocknumber == 0 --> handle sparse file
       if (!block_number)
       {
         return kstd::failure(block_number.error());
       }
 
-      auto const bytes_to_write =
-          std::min(kstd::bytes{buffer.size()} - bytes_written, (*filesystem)->block_size() - in_block_offset);
+      auto const bytes_to_write = std::min(kstd::bytes{buffer.size()} - bytes_written, block_size - in_block_offset);
 
-      auto const block_start_offset = block_number.value() * (*filesystem)->block_size();
+      auto const block_start_offset = block_number.value() * block_size;
       auto const write_offset = block_start_offset + in_block_offset;
 
       auto inode = backing_inode();
@@ -166,7 +185,7 @@ namespace kernel::filesystem::ext2
     }
 
     set_size(std::max(this->size(), offset + bytes_written));
-    if (auto write_result = (*filesystem)->write_inode(m_inode_number, m_data); !write_result)
+    if (auto write_result = (*filesystem)->write_inode(m_inode_number, m_data, *state); !write_result)
     {
       return kstd::failure(write_result.error());
     }
@@ -182,7 +201,15 @@ namespace kernel::filesystem::ext2
       return false;
     }
 
-    auto new_blocks = (*filesystem)->allocate_blocks(count);
+    auto driver_data = get_driver_data();
+    if (!driver_data)
+    {
+      return false;
+    }
+
+    auto state = static_pointer_cast<mount_state>(*driver_data);
+
+    auto new_blocks = (*filesystem)->allocate_blocks(count, *state);
     if (!new_blocks)
     {
       return false;
@@ -190,18 +217,19 @@ namespace kernel::filesystem::ext2
 
     for (auto i = 0uz; i < new_blocks->size(); ++i)
     {
-      auto const block_index = (*filesystem)->inode_block_count(m_data) + i;
+      auto const block_index = (*filesystem)->inode_block_count(m_data, *state) + i;
       auto const global_block_number = new_blocks->at(i);
 
       if (auto write_result =
-              (*filesystem)->write_global_block_number_to_inode_block_index(block_index, m_data, global_block_number);
+              (*filesystem)
+                  ->write_global_block_number_to_inode_block_index(block_index, m_data, global_block_number, *state);
           !write_result)
       {
         return false;
       }
     }
 
-    (*filesystem)->update_inode_block_count(m_data, count);
+    (*filesystem)->update_inode_block_count(m_data, count, *state);
     return true;
   }
 
@@ -281,7 +309,15 @@ namespace kernel::filesystem::ext2
       return 0_B;
     }
 
-    if ((*filesystem)->revision_level() > constants::good_old_revision && is_regular())
+    auto driver_data = get_driver_data();
+    if (!driver_data)
+    {
+      return 0_B;
+    }
+
+    auto state = static_pointer_cast<mount_state const>(*driver_data);
+
+    if ((*filesystem)->revision_level(*state) > constants::good_old_revision && is_regular())
     {
       size |= static_cast<uint64_t>(m_data.dir_acl) << 32;
     }
@@ -297,7 +333,15 @@ namespace kernel::filesystem::ext2
       return;
     }
 
-    if ((*filesystem)->revision_level() > constants::good_old_revision && is_regular())
+    auto driver_data = get_driver_data();
+    if (!driver_data)
+    {
+      return;
+    }
+
+    auto state = static_pointer_cast<mount_state>(*driver_data);
+
+    if ((*filesystem)->revision_level(*state) > constants::good_old_revision && is_regular())
     {
       m_data.dir_acl = static_cast<uint32_t>(new_size.value >> 32);
     }
@@ -349,4 +393,24 @@ namespace kernel::filesystem::ext2
     return kstd::failure(vfs_errc::not_mounted);
   }
 
+  auto inode::get_driver_data() -> kstd::result<kstd::shared_ptr<void>>
+  {
+    if (auto mount = owning_mount().lock())
+    {
+      return mount->driver_data();
+    }
+
+    return kstd::failure(vfs_errc::not_mounted);
+  }
+
+  auto inode::get_driver_data() const -> kstd::result<kstd::shared_ptr<void const>>
+  {
+    if (auto mount = owning_mount().lock())
+    {
+      return mount->driver_data();
+    }
+
+    return kstd::failure(vfs_errc::not_mounted);
+  }
+
 }  // namespace kernel::filesystem::ext2