kernel/fs: ext2: externalize mount state

7 files changed, 340 insertions, 219 deletions

diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index 9275f5a9..ef81f6ac 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -97,44 +97,48 @@ namespace kernel::filesystem::ext2
   [[gnu::used]]
   constexpr auto registration = type_registration<type>{};
 
-  auto filesystem::indirect_levels() const -> std::array<indirect_level, 3>
+  static_assert(sizeof(kernel::filesystem::filesystem) == sizeof(kernel::filesystem::ext2::filesystem));
+
+  auto filesystem::indirect_levels(mount_state const & state) const -> std::array<indirect_level, 3>
   {
     return {
-      {{constants::singly_indirect_block_index, block_numbers_per_singly_indirect_block()},
-       {constants::doubly_indirect_block_index, block_numbers_per_doubly_indirect_block()},
-       {constants::triply_indirect_block_index, block_numbers_per_triply_indirect_block()}}
+      {{constants::singly_indirect_block_index, block_numbers_per_singly_indirect_block(state)},
+       {constants::doubly_indirect_block_index, block_numbers_per_doubly_indirect_block(state)},
+       {constants::triply_indirect_block_index, block_numbers_per_triply_indirect_block(state)}}
     };
   }
 
   auto filesystem::mount(inode_ptr const & backing_inode) -> kstd::result<mount_result>
   {
-    m_backing_inode = backing_inode;
+    auto mount_state = kstd::make_shared<struct mount_state>();
+    auto & [superblock, block_group_descriptors, backing] = *mount_state;
 
-    if (auto read_result =
-            m_backing_inode->read(std::as_writable_bytes(std::span{&m_superblock, 1}), constants::superblock_offset);
-        !read_result)
+    backing = backing_inode;
+
+    auto superblock_bytes = std::as_writable_bytes(std::span{&superblock, 1});
+    if (auto read_result = backing->read(superblock_bytes, constants::superblock_offset); !read_result)
     {
       return kstd::failure(read_result.error());
     }
 
-    if (m_superblock.magic != constants::magic_number)
+    if (superblock.magic != constants::magic_number)
     {
       return kstd::failure(ext2_errc::invalid_magic_number);
     }
 
-    auto const blocks_per_group = m_superblock.blocks_per_group;
-    auto const num_block_groups = (m_superblock.blocks_count + blocks_per_group - 1) / blocks_per_group;
+    auto const blocks_per_group = superblock.blocks_per_group;
+    auto const num_block_groups = (superblock.blocks_count + blocks_per_group - 1) / blocks_per_group;
 
-    m_block_group_descriptors = kstd::vector<block_group_descriptor>(num_block_groups);
-
-    if (auto read_result = m_backing_inode->read(std::as_writable_bytes(std::span{m_block_group_descriptors}),
-                                                 block_group_descriptor_table_offset());
+    block_group_descriptors = kstd::vector<block_group_descriptor>(num_block_groups);
+    auto block_group_descriptors_bytes = std::as_writable_bytes(std::span{block_group_descriptors});
+    if (auto read_result =
+            backing->read(block_group_descriptors_bytes, block_group_descriptor_table_offset(*mount_state));
         !read_result)
     {
       return kstd::failure(read_result.error());
     }
 
-    auto root = read_inode(constants::root_inode_number);
+    auto root = read_inode(constants::root_inode_number, *mount_state);
 
     if (!root)
     {
@@ -146,8 +150,7 @@ namespace kernel::filesystem::ext2
       return kstd::failure(ext2_errc::invalid_root_inode);
     }
 
-    return mount_result{*root,
-                        kstd::make_shared<mount_state>(m_superblock, m_block_group_descriptors, m_backing_inode)};
+    return mount_result{*root, mount_state};
   }
 
   auto filesystem::lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) const
@@ -171,17 +174,17 @@ namespace kernel::filesystem::ext2
 
     auto * ext2_parent = static_cast<inode *>(parent.get());
     auto const & inode_data = ext2_parent->data();
-    kstd::vector<uint8_t> buffer(block_size().value);
+    kstd::vector<uint8_t> buffer(block_size(*mount_state).value);
 
-    for (uint32_t i = 0; i < inode_block_count(inode_data); ++i)
+    for (uint32_t i = 0; i < inode_block_count(inode_data, *mount_state); ++i)
     {
-      auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data);
+      auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data, *mount_state);
       if (!global_block_number)
       {
         return kstd::failure(global_block_number.error());
       }
 
-      if (auto read_result = read_block(*global_block_number, buffer.data()); !read_result)
+      if (auto read_result = read_block(*global_block_number, buffer.data(), *mount_state); !read_result)
       {
         return kstd::failure(read_result.error());
       }
@@ -189,12 +192,12 @@ namespace kernel::filesystem::ext2
       auto const * entry = reinterpret_cast<linked_directory_entry const *>(buffer.data());
       auto bytes_read = 0_B;
 
-      while (bytes_read < block_size() && entry->inode != 0)
+      while (bytes_read < block_size(*mount_state) && entry->inode != 0)
       {
         auto const entry_name = std::string_view{entry->name.data(), entry->name_len};
         if (entry_name == name)
         {
-          return read_inode(entry->inode);
+          return read_inode(entry->inode, *mount_state);
         }
 
         bytes_read += kstd::bytes{entry->rec_len};
@@ -237,7 +240,7 @@ namespace kernel::filesystem::ext2
       return kstd::failure(vfs_errc::invalid_driver_data);
     }
 
-    auto maybe_inode_number = allocate_inode();
+    auto maybe_inode_number = allocate_inode(*mount_state);
     if (!maybe_inode_number)
     {
       return kstd::failure(maybe_inode_number.error());
@@ -263,7 +266,7 @@ namespace kernel::filesystem::ext2
 
     // 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)
+    if (auto result = add_directory_entry(ext2_parent, name, inode_number, new_inode_data.mode, *mount_state); !result)
     {
       return kstd::failure(result.error());
     }
@@ -274,13 +277,13 @@ namespace kernel::filesystem::ext2
     if (new_inode->is_directory())
     {
       // TODO increment used_dirs_count in block group descriptor
-      if (auto result = init_directory(new_inode, ext2_parent); !result)
+      if (auto result = init_directory(new_inode, ext2_parent, *mount_state); !result)
       {
         return kstd::failure(result.error());
       }
     }
 
-    if (auto write_result = write_inode(inode_number, new_inode->data()); !write_result)
+    if (auto write_result = write_inode(inode_number, new_inode->data(), *mount_state); !write_result)
     {
       return kstd::failure(write_result.error());
     }
@@ -289,18 +292,19 @@ namespace kernel::filesystem::ext2
   }
 
   auto filesystem::add_directory_entry(inode * ext2_parent, std::string_view name, uint32_t child_inode_number,
-                                       [[maybe_unused]] uint16_t mode) -> kstd::result<void>
+                                       [[maybe_unused]] uint16_t mode, mount_state & state) -> kstd::result<void>
   {
-    auto const last_block_index = inode_block_count(ext2_parent->data()) - 1;
-    auto const global_block = map_inode_block_index_to_global_block_number(last_block_index, ext2_parent->data());
+    auto const last_block_index = inode_block_count(ext2_parent->data(), state) - 1;
+    auto const global_block =
+        map_inode_block_index_to_global_block_number(last_block_index, ext2_parent->data(), state);
 
     if (!global_block)
     {
       return kstd::failure(global_block.error());
     }
 
-    kstd::vector<uint8_t> buffer(block_size().value);
-    if (auto read_result = read_block(*global_block, buffer.data()); !read_result)
+    kstd::vector<uint8_t> buffer(block_size(state).value);
+    if (auto read_result = read_block(*global_block, buffer.data(), state); !read_result)
     {
       return kstd::failure(read_result.error());
     }
@@ -311,7 +315,7 @@ namespace kernel::filesystem::ext2
     while (true)
     {
       auto const * entry = reinterpret_cast<linked_directory_entry const *>(buffer.data() + offset);
-      if (offset + kstd::bytes{entry->rec_len} >= block_size())
+      if (offset + kstd::bytes{entry->rec_len} >= block_size(state))
       {
         break;
       }
@@ -329,8 +333,8 @@ namespace kernel::filesystem::ext2
     {
       last_entry->rec_len = last_entry_actual_len.value;
       write_directory_entry_to_buffer(buffer.data(), offset + last_entry_actual_len, child_inode_number, name,
-                                      file_type);
-      return global_block.and_then([&](auto block_number) { return write_block(block_number, buffer.data()); })
+                                      file_type, state);
+      return global_block.and_then([&](auto block_number) { return write_block(block_number, buffer.data(), state); })
           .transform([](auto) {});
     }
     else
@@ -340,79 +344,82 @@ namespace kernel::filesystem::ext2
         return kstd::failure(ext2_errc::not_enough_free_blocks);
       }
 
-      auto const new_block_index = inode_block_count(ext2_parent->data()) - 1;
-      auto const new_global_block = map_inode_block_index_to_global_block_number(new_block_index, ext2_parent->data());
+      auto const new_block_index = inode_block_count(ext2_parent->data(), state) - 1;
+      auto const new_global_block =
+          map_inode_block_index_to_global_block_number(new_block_index, ext2_parent->data(), state);
       if (!new_global_block)
       {
         return kstd::failure(new_global_block.error());
       }
 
-      kstd::libc::memset(buffer.data(), 0, block_size().value);
-      write_directory_entry_to_buffer(buffer.data(), 0_B, child_inode_number, name, file_type);
-      if (auto update_result =
-              new_global_block.and_then([&](auto block_number) { return write_block(block_number, buffer.data()); });
+      kstd::libc::memset(buffer.data(), 0, block_size(state).value);
+      write_directory_entry_to_buffer(buffer.data(), 0_B, child_inode_number, name, file_type, state);
+      if (auto update_result = new_global_block.and_then(
+              [&](auto block_number) { return write_block(block_number, buffer.data(), state); });
           !update_result)
       {
         return kstd::failure(update_result.error());
       }
     }
 
-    ext2_parent->data_mutable().size = (inode_block_count(ext2_parent->data()) * block_size()).value;
-    return write_inode(ext2_parent->number(), ext2_parent->data());
+    ext2_parent->data_mutable().size = (inode_block_count(ext2_parent->data(), state) * block_size(state)).value;
+    return write_inode(ext2_parent->number(), ext2_parent->data(), state);
   }
 
   auto filesystem::init_directory(kstd::shared_ptr<kernel::filesystem::ext2::inode> const & new_inode,
-                                  kernel::filesystem::ext2::inode * parent_inode) -> kstd::result<void>
+                                  kernel::filesystem::ext2::inode * parent_inode, mount_state & state)
+      -> kstd::result<void>
   {
     if (!new_inode->append_blocks(1))
     {
       return kstd::failure(ext2_errc::not_enough_free_blocks);
     }
 
-    auto const global_block = map_inode_block_index_to_global_block_number(0, new_inode->data());
+    auto const global_block = map_inode_block_index_to_global_block_number(0, new_inode->data(), state);
     if (!global_block)
     {
       return kstd::failure(global_block.error());
     }
 
-    kstd::vector<uint8_t> buffer(block_size().value, 0);
-    write_directory_entry_to_buffer(buffer.data(), 0_B, new_inode->number(), ".", 2);
+    kstd::vector<uint8_t> buffer(block_size(state).value, 0);
+    write_directory_entry_to_buffer(buffer.data(), 0_B, new_inode->number(), ".", 2, state);
     auto const dot_actual_len = static_cast<kstd::bytes>((8u + 1 + 3u) & ~3u);
     auto * entry = reinterpret_cast<linked_directory_entry *>(buffer.data());
     entry->rec_len = dot_actual_len.value;
 
-    write_directory_entry_to_buffer(buffer.data(), dot_actual_len, parent_inode->number(), "..", 2);
+    write_directory_entry_to_buffer(buffer.data(), dot_actual_len, parent_inode->number(), "..", 2, state);
 
     // '..' inside the new dir counts as an extra hard link to the parent
     auto & parent_inode_data = parent_inode->data_mutable();
     parent_inode_data.links_count++;
 
-    return write_inode(parent_inode->number(), parent_inode_data)
+    return write_inode(parent_inode->number(), parent_inode_data, state)
         .and_then([&]() { return global_block; })
-        .and_then([&](auto block_number) { return write_block(block_number, buffer.data()); })
+        .and_then([&](auto block_number) { return write_block(block_number, buffer.data(), state); })
         .transform([](auto) {});
   }
 
   auto filesystem::write_directory_entry_to_buffer(uint8_t * block_buffer, kstd::bytes offset,
                                                    uint32_t child_inode_number, std::string_view name,
-                                                   uint8_t file_type) -> void
+                                                   uint8_t file_type, mount_state & state) -> void
   {
     auto const name_len = static_cast<uint8_t>(name.size());
     auto * entry = reinterpret_cast<linked_directory_entry *>(block_buffer + offset);
     entry->inode = child_inode_number;
-    entry->rec_len = static_cast<uint16_t>(block_size() - offset);
+    entry->rec_len = static_cast<uint16_t>(block_size(state) - offset);
     entry->name_len = name_len;
     entry->file_type = file_type;
     kstd::libc::memcpy(entry->name.data(), name.data(), name_len);
   }
 
-  auto filesystem::read_inode(uint32_t inode_number) const -> kstd::result<kstd::shared_ptr<inode>>
+  auto filesystem::read_inode(uint32_t inode_number, mount_state const & state) const
+      -> kstd::result<kstd::shared_ptr<inode>>
   {
-    if (auto inode_offset = calculate_inode_offset(inode_number))
+    if (auto inode_offset = calculate_inode_offset(inode_number, state))
     {
       auto new_inode_data = inode_data{};
 
-      if (auto read_result = m_backing_inode->read(as_writable_bytes(std::span{&new_inode_data, 1}), *inode_offset);
+      if (auto read_result = state.backing_inode->read(as_writable_bytes(std::span{&new_inode_data, 1}), *inode_offset);
           !read_result)
       {
         return kstd::failure(read_result.error());
@@ -428,11 +435,12 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto filesystem::write_inode(uint32_t inode_number, inode_data const & data) -> kstd::result<void>
+  auto filesystem::write_inode(uint32_t inode_number, inode_data const & data, mount_state & state)
+      -> kstd::result<void>
   {
-    if (auto inode_offset = calculate_inode_offset(inode_number))
+    if (auto inode_offset = calculate_inode_offset(inode_number, state))
     {
-      return m_backing_inode->write(as_bytes(std::span{&data, 1}), *inode_offset).transform([](auto) {});
+      return state.backing_inode->write(as_bytes(std::span{&data, 1}), *inode_offset).transform([](auto) {});
     }
     else
     {
@@ -440,51 +448,54 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto filesystem::calculate_inode_offset(uint32_t inode_number) const -> kstd::result<kstd::bytes>
+  auto filesystem::calculate_inode_offset(uint32_t inode_number, mount_state const & state) const
+      -> kstd::result<kstd::bytes>
   {
-    auto const inodes_per_group = m_superblock.inodes_per_group;
+    auto const inodes_per_group = state.superblock.inodes_per_group;
     auto const block_group_index = (inode_number - 1) / inodes_per_group;
     auto const inode_index_within_group = (inode_number - 1) % inodes_per_group;
 
-    if (block_group_index >= m_block_group_descriptors.size())
+    if (block_group_index >= state.block_group_descriptors.size())
     {
       return kstd::failure(ext2_errc::invalid_block_group_index);
     }
 
-    auto const & block_group_descriptor = m_block_group_descriptors.at(block_group_index);
+    auto const & block_group_descriptor = state.block_group_descriptors.at(block_group_index);
     auto const inode_table_start_block = block_group_descriptor.inode_table;
-    auto const inode_table_offset = inode_table_start_block * block_size();
-    auto const inode_offset = inode_table_offset + inode_index_within_group * inode_size();
+    auto const inode_table_offset = inode_table_start_block * block_size(state);
+    auto const inode_offset = inode_table_offset + inode_index_within_group * inode_size(state);
 
     return inode_offset;
   }
 
-  auto filesystem::allocate_blocks(size_t count) -> kstd::result<kstd::vector<uint32_t>>
+  auto filesystem::allocate_blocks(size_t count, mount_state & state) -> kstd::result<kstd::vector<uint32_t>>
   {
-    if (m_block_group_descriptors.empty() || count > m_superblock.free_blocks_count)
+    auto & [superblock, block_group_descriptors, backing_inode] = state;
+
+    if (block_group_descriptors.empty() || count > superblock.free_blocks_count)
     {
       return kstd::failure(ext2_errc::not_enough_free_blocks);
     }
 
     kstd::vector<uint32_t> allocated_blocks{};
 
-    for (auto block_group_descriptor_index = 0uz; block_group_descriptor_index < m_block_group_descriptors.size();
+    for (auto block_group_descriptor_index = 0uz; block_group_descriptor_index < block_group_descriptors.size();
          ++block_group_descriptor_index)
     {
-      auto & block_group_descriptor = m_block_group_descriptors.at(block_group_descriptor_index);
+      auto & block_group_descriptor = block_group_descriptors.at(block_group_descriptor_index);
       if (block_group_descriptor.free_blocks_count == 0)
       {
         continue;
       }
 
-      kstd::vector<uint8_t> block_bitmap(block_size().value, 0);
-      if (auto read_result = read_block(block_group_descriptor.block_bitmap, block_bitmap.data()); !read_result)
+      kstd::vector<uint8_t> block_bitmap(block_size(state).value, 0);
+      if (auto read_result = read_block(block_group_descriptor.block_bitmap, block_bitmap.data(), state); !read_result)
       {
         return kstd::failure(read_result.error());
       }
 
       bool is_bitmap_dirty = false;
-      for (auto i = 0uz; i < static_cast<size_t>(m_superblock.blocks_per_group) && allocated_blocks.size() < count; ++i)
+      for (auto i = 0uz; i < static_cast<size_t>(superblock.blocks_per_group) && allocated_blocks.size() < count; ++i)
       {
         if (!bitmap_is_set(block_bitmap, i))
         {
@@ -492,24 +503,25 @@ namespace kernel::filesystem::ext2
 
           bitmap_set(block_bitmap, i);
           block_group_descriptor.free_blocks_count--;
-          m_superblock.free_blocks_count--;
+          superblock.free_blocks_count--;
 
-          allocated_blocks.push_back(i + block_group_descriptor_index * m_superblock.blocks_per_group);
+          allocated_blocks.push_back(i + block_group_descriptor_index * superblock.blocks_per_group);
         }
       }
 
       if (is_bitmap_dirty)
       {
-        if (auto write_result = write_block(block_group_descriptor.block_bitmap, block_bitmap.data()); !write_result)
+        if (auto write_result = write_block(block_group_descriptor.block_bitmap, block_bitmap.data(), state);
+            !write_result)
         {
           return kstd::failure(write_result.error());
         }
 
         // TODO update all block group descriptors
         if (auto write_result =
-                m_backing_inode->write(as_bytes(std::span{&block_group_descriptor, 1}),
-                                       block_group_descriptor_table_offset() +
-                                           block_group_descriptor_index * kstd::size_of(block_group_descriptor));
+                backing_inode->write(as_bytes(std::span{&block_group_descriptor, 1}),
+                                     block_group_descriptor_table_offset(state) +
+                                         block_group_descriptor_index * kstd::size_of(block_group_descriptor));
             !write_result)
         {
           return kstd::failure(write_result.error());
@@ -517,8 +529,8 @@ namespace kernel::filesystem::ext2
       }
     }
 
-    // TODO update all superblocks
-    if (auto write_result = m_backing_inode->write(as_bytes(std::span{&m_superblock, 1}), constants::superblock_offset);
+    // TODO update all superblock copies
+    if (auto write_result = backing_inode->write(as_bytes(std::span{&superblock, 1}), constants::superblock_offset);
         !write_result)
     {
       return kstd::failure(write_result.error());
@@ -532,54 +544,58 @@ namespace kernel::filesystem::ext2
     return allocated_blocks;
   }
 
-  auto filesystem::allocate_inode() -> kstd::result<uint32_t>
+  auto filesystem::allocate_inode(mount_state & state) -> kstd::result<uint32_t>
   {
-    if (m_block_group_descriptors.empty() || m_superblock.free_inodes_count == 0)
+    auto & [superblock, block_group_descriptors, _] = state;
+
+    if (block_group_descriptors.empty() || superblock.free_inodes_count == 0)
     {
       return kstd::failure(ext2_errc::not_enough_inodes);
     }
 
-    for (auto block_group_descriptor_index = 0uz; block_group_descriptor_index < m_block_group_descriptors.size();
+    for (auto block_group_descriptor_index = 0uz; block_group_descriptor_index < block_group_descriptors.size();
          ++block_group_descriptor_index)
     {
-      auto & block_group_descriptor = m_block_group_descriptors.at(block_group_descriptor_index);
+      auto & block_group_descriptor = block_group_descriptors.at(block_group_descriptor_index);
       if (block_group_descriptor.free_inodes_count == 0)
       {
         continue;
       }
 
-      kstd::vector<uint8_t> inode_bitmap(block_size().value, 0);
-      if (auto read_result = read_block(block_group_descriptor.inode_bitmap, inode_bitmap.data()); !read_result)
+      kstd::vector<uint8_t> inode_bitmap(block_size(state).value, 0);
+      if (auto read_result = read_block(block_group_descriptor.inode_bitmap, inode_bitmap.data(), state); !read_result)
       {
         return kstd::failure(read_result.error());
       }
 
-      for (auto i = 0uz; i < static_cast<size_t>(m_superblock.inodes_per_group); ++i)
+      for (auto i = 0uz; i < static_cast<size_t>(superblock.inodes_per_group); ++i)
       {
         if (!bitmap_is_set(inode_bitmap, i))
         {
           bitmap_set(inode_bitmap, i);
           block_group_descriptor.free_inodes_count--;
-          m_superblock.free_inodes_count--;
+          superblock.free_inodes_count--;
 
-          if (auto write_result = write_block(block_group_descriptor.inode_bitmap, inode_bitmap.data()); !write_result)
+          if (auto write_result = write_block(block_group_descriptor.inode_bitmap, inode_bitmap.data(), state);
+              !write_result)
           {
             return kstd::failure(write_result.error());
           }
 
-          if (auto write_result = write_block_group_descriptor(block_group_descriptor, block_group_descriptor_index);
+          if (auto write_result =
+                  write_block_group_descriptor(block_group_descriptor, block_group_descriptor_index, state);
               !write_result)
           {
             return kstd::failure(write_result.error());
           }
 
           // TODO update all superblocks
-          if (auto write_result = write_superblock(); !write_result)
+          if (auto write_result = write_superblock(state); !write_result)
           {
             return kstd::failure(write_result.error());
           }
 
-          return block_group_descriptor_index * m_superblock.inodes_per_group + i + 1;
+          return block_group_descriptor_index * superblock.inodes_per_group + i + 1;
         }
       }
     }
@@ -587,7 +603,8 @@ namespace kernel::filesystem::ext2
     return kstd::failure(ext2_errc::not_enough_inodes);
   }
 
-  auto filesystem::map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data) const
+  auto filesystem::map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data,
+                                                                mount_state const & state) const
       -> kstd::result<std::size_t>
   {
     if (inode_block_index < constants::direct_block_count)
@@ -597,7 +614,7 @@ namespace kernel::filesystem::ext2
 
     inode_block_index -= constants::direct_block_count;
 
-    for (auto const & level : indirect_levels())
+    for (auto const & level : indirect_levels(state))
     {
       if (inode_block_index >= level.capacity)
       {
@@ -611,12 +628,12 @@ namespace kernel::filesystem::ext2
         return 0;
       }
 
-      for (auto stride = level.capacity / block_numbers_per_block();; stride /= block_numbers_per_block())
+      for (auto stride = level.capacity / block_numbers_per_block(state);; stride /= block_numbers_per_block(state))
       {
         auto const idx = inode_block_index / stride;
         inode_block_index %= stride;
 
-        if (auto read_result = read_block_number_at_index(block_number, idx); !read_result)
+        if (auto read_result = read_block_number_at_index(block_number, idx, state); !read_result)
         {
           return kstd::failure(read_result.error());
         }
@@ -642,14 +659,15 @@ namespace kernel::filesystem::ext2
     return kstd::failure(ext2_errc::invalid_block_index);
   }
 
-  auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> kstd::result<uint32_t>
+  auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index, mount_state const & state) const
+      -> kstd::result<uint32_t>
   {
     uint32_t block_number_buffer = 0;
 
-    auto const block_start_offset = block_number * block_size();
+    auto const block_start_offset = block_number * block_size(state);
     auto const number_start_address = block_start_offset + index * kstd::size_of<uint32_t>();
     if (auto read_result =
-            m_backing_inode->read(as_writable_bytes(std::span{&block_number_buffer, 1}), number_start_address);
+            state.backing_inode->read(as_writable_bytes(std::span{&block_number_buffer, 1}), number_start_address);
         !read_result)
     {
       return kstd::failure(read_result.error());
@@ -659,7 +677,8 @@ namespace kernel::filesystem::ext2
   }
 
   auto filesystem::write_global_block_number_to_inode_block_index(size_t inode_block_index, inode_data & data,
-                                                                  uint32_t global_block_number) -> kstd::result<void>
+                                                                  uint32_t global_block_number, mount_state & state)
+      -> kstd::result<void>
   {
     if (inode_block_index < constants::direct_block_count)
     {
@@ -668,7 +687,7 @@ namespace kernel::filesystem::ext2
     }
     inode_block_index -= constants::direct_block_count;
 
-    for (auto const & level : indirect_levels())
+    for (auto const & level : indirect_levels(state))
     {
       if (inode_block_index >= level.capacity)
       {
@@ -676,18 +695,19 @@ namespace kernel::filesystem::ext2
         continue;
       }
 
+      auto & backing_inode = state.backing_inode;
       auto block_number = data.block[level.slot_index];
       auto parent_byte_offset = 0_B;
       bool is_root = true;
 
-      for (auto stride = level.capacity / block_numbers_per_block();; stride /= block_numbers_per_block())
+      for (auto stride = level.capacity / block_numbers_per_block(state);; stride /= block_numbers_per_block(state))
       {
         auto const idx = inode_block_index / stride;
         inode_block_index %= stride;
 
         if (idx == 0 && inode_block_index == 0)
         {
-          auto allocated = allocate_blocks(1);
+          auto allocated = allocate_blocks(1, state);
           if (!allocated)
           {
             return kstd::failure(allocated.error());
@@ -701,7 +721,7 @@ namespace kernel::filesystem::ext2
           }
           else
           {
-            if (auto write_result = m_backing_inode->write(as_bytes(std::span{&block_number, 1}), parent_byte_offset);
+            if (auto write_result = backing_inode->write(as_bytes(std::span{&block_number, 1}), parent_byte_offset);
                 !write_result)
             {
               return kstd::failure(write_result.error());
@@ -709,11 +729,11 @@ namespace kernel::filesystem::ext2
           }
         }
 
-        auto const byte_offset = block_number * block_size() + idx * kstd::size_of<uint32_t>();
+        auto const byte_offset = block_number * block_size(state) + idx * kstd::size_of<uint32_t>();
 
         if (stride == 1)
         {
-          if (auto write_result = m_backing_inode->write(as_bytes(std::span{&global_block_number, 1}), byte_offset);
+          if (auto write_result = backing_inode->write(as_bytes(std::span{&global_block_number, 1}), byte_offset);
               !write_result)
           {
             return kstd::failure(write_result.error());
@@ -723,7 +743,7 @@ namespace kernel::filesystem::ext2
 
         parent_byte_offset = byte_offset;
         is_root = false;
-        if (auto read_result = read_block_number_at_index(block_number, idx); !read_result)
+        if (auto read_result = read_block_number_at_index(block_number, idx, state); !read_result)
         {
           return kstd::failure(read_result.error());
         }
@@ -737,38 +757,38 @@ namespace kernel::filesystem::ext2
     return kstd::success();
   }
 
-  auto filesystem::backing_inode() const -> kstd::shared_ptr<kernel::filesystem::inode> const &
-  {
-    return m_backing_inode;
-  }
-
-  auto filesystem::read_block(uint32_t block_number, void * buffer) const -> kstd::result<kstd::bytes>
+  auto filesystem::read_block(uint32_t block_number, void * buffer, mount_state & state) const
+      -> kstd::result<kstd::bytes>
   {
-    auto const block_offset = static_cast<size_t>(block_number) * block_size();
-    return m_backing_inode->read(std::span{static_cast<std::byte *>(buffer), block_size().value}, block_offset);
+    auto const block_offset = static_cast<size_t>(block_number) * block_size(state);
+    return state.backing_inode->read(std::span{static_cast<std::byte *>(buffer), block_size(state).value},
+                                     block_offset);
   }
 
-  auto filesystem::write_block(uint32_t block_number, void const * buffer) -> kstd::result<kstd::bytes>
+  auto filesystem::write_block(uint32_t block_number, void const * buffer, mount_state & state)
+      -> kstd::result<kstd::bytes>
   {
-    auto const block_offset = static_cast<size_t>(block_number) * block_size();
-    return m_backing_inode->write(std::span{static_cast<std::byte const *>(buffer), block_size().value}, block_offset);
+    auto const block_offset = static_cast<size_t>(block_number) * block_size(state);
+    return state.backing_inode->write(std::span{static_cast<std::byte const *>(buffer), block_size(state).value},
+                                      block_offset);
   }
 
   auto filesystem::write_block_group_descriptor(block_group_descriptor const & block_group_descriptor,
-                                                size_t block_group_descriptor_index) const -> kstd::result<void>
+                                                size_t block_group_descriptor_index, mount_state const & state) const
+      -> kstd::result<void>
   {
     // TODO update all block group descriptors
-    return m_backing_inode
+    return state.backing_inode
         ->write(as_bytes(std::span{&block_group_descriptor, 1}),
-                block_group_descriptor_table_offset() +
+                block_group_descriptor_table_offset(state) +
                     block_group_descriptor_index * kstd::size_of(block_group_descriptor))
         .transform([](auto) {});
   }
 
-  auto filesystem::write_superblock() const -> kstd::result<void>
+  auto filesystem::write_superblock(mount_state & state) const -> kstd::result<void>
   {
-    // TODO update all superblocks
-    return m_backing_inode->write(as_bytes(std::span{&m_superblock, 1}), constants::superblock_offset)
+    // TODO update all superblock copies
+    return state.backing_inode->write(as_bytes(std::span{&state.superblock, 1}), constants::superblock_offset)
         .transform([](auto) {});
   }
 
@@ -806,54 +826,54 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto filesystem::block_numbers_per_block() const -> size_t
+  auto filesystem::block_numbers_per_block(mount_state const & state) const -> size_t
   {
-    return block_size() / kstd::size_of<uint32_t>();
+    return block_size(state) / kstd::size_of<uint32_t>();
   }
 
-  auto filesystem::block_numbers_per_singly_indirect_block() const -> size_t
+  auto filesystem::block_numbers_per_singly_indirect_block(mount_state const & state) const -> size_t
   {
-    return block_numbers_per_block();
+    return block_numbers_per_block(state);
   }
 
-  auto filesystem::block_numbers_per_doubly_indirect_block() const -> size_t
+  auto filesystem::block_numbers_per_doubly_indirect_block(mount_state const & state) const -> size_t
   {
-    return block_numbers_per_singly_indirect_block() * block_numbers_per_block();
+    return block_numbers_per_singly_indirect_block(state) * block_numbers_per_block(state);
   }
 
-  auto filesystem::block_numbers_per_triply_indirect_block() const -> size_t
+  auto filesystem::block_numbers_per_triply_indirect_block(mount_state const & state) const -> size_t
   {
-    return block_numbers_per_doubly_indirect_block() * block_numbers_per_block();
+    return block_numbers_per_doubly_indirect_block(state) * block_numbers_per_block(state);
   }
 
-  auto filesystem::block_size() const -> kstd::bytes
+  auto filesystem::block_size(mount_state const & state) const -> kstd::bytes
   {
-    return kstd::bytes{constants::base_block_size.value << m_superblock.log_block_size};
+    return kstd::bytes{constants::base_block_size.value << state.superblock.log_block_size};
   }
 
-  auto filesystem::revision_level() const -> uint32_t
+  auto filesystem::revision_level(mount_state const & state) const -> uint32_t
   {
-    return m_superblock.rev_level;
+    return state.superblock.rev_level;
   }
 
-  auto filesystem::inode_size() const -> kstd::bytes
+  auto filesystem::inode_size(mount_state const & state) const -> kstd::bytes
   {
-    return kstd::bytes(revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size);
+    return kstd::bytes(revision_level(state) == constants::good_old_revision ? 128 : state.superblock.inode_size);
   }
 
-  auto filesystem::inode_block_count(inode_data const & data) const -> uint32_t
+  auto filesystem::inode_block_count(inode_data const & data, mount_state const & state) const -> uint32_t
   {
-    return data.blocks / (2 << m_superblock.log_block_size);
+    return data.blocks / (2 << state.superblock.log_block_size);
   }
 
-  auto filesystem::update_inode_block_count(inode_data & data, uint32_t delta) -> void
+  auto filesystem::update_inode_block_count(inode_data & data, uint32_t delta, mount_state & state) -> void
   {
-    data.blocks += delta * (2 << m_superblock.log_block_size);
+    data.blocks += delta * (2 << state.superblock.log_block_size);
   }
 
-  auto filesystem::block_group_descriptor_table_offset() const -> kstd::bytes
+  auto filesystem::block_group_descriptor_table_offset(mount_state const & state) const -> kstd::bytes
   {
-    return block_size() == 1024_B ? 2 * block_size() : block_size();
+    return block_size(state) == 1024_B ? 2 * block_size(state) : block_size(state);
   }
 
 }  // namespace kernel::filesystem::ext2
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index c6f8b04a..ef7afdfb 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -3,6 +3,7 @@
 
 #include <kernel/filesystem/ext2/block_group_descriptor.hpp>
 #include <kernel/filesystem/ext2/inode.hpp>
+#include <kernel/filesystem/ext2/mount_state.hpp>
 #include <kernel/filesystem/ext2/superblock.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/inode.hpp>
@@ -88,71 +89,81 @@ namespace kernel::filesystem::ext2
     //! Get the size of a block in the filesystem.
     //!
     //! @return The size of a block in bytes.
-    [[nodiscard]] auto block_size() const -> kstd::bytes;
+    [[nodiscard]] auto block_size(mount_state const & state) const -> kstd::bytes;
 
     //! Get the revision level of the filesystem.
     //!
     //! @return The revision level.
-    [[nodiscard]] auto revision_level() const -> uint32_t;
+    [[nodiscard]] auto revision_level(mount_state const & state) const -> uint32_t;
 
     //! Read a block from the backing inode into the provided buffer.
     //!
     //! @param block_number The number of the block to read.
     //! @param buffer The buffer to read the block data into.
+    //! @param state The state to operate on.
     //! @return The number of bytes read.
-    auto read_block(uint32_t block_number, void * buffer) const -> kstd::result<kstd::bytes>;
+    auto read_block(uint32_t block_number, void * buffer, mount_state & state) const -> kstd::result<kstd::bytes>;
 
     //! Write a block of data from the provided buffer to the backing inode.
     //!
     //! @param block_number The number of the block to write.
     //! @param buffer The buffer containing the data to write.
+    //! @param state The state to operate on.
     //! @return The number of bytes written.
-    auto write_block(uint32_t block_number, void const * buffer) -> kstd::result<kstd::bytes>;
+    auto write_block(uint32_t block_number, void const * buffer, mount_state & state) -> kstd::result<kstd::bytes>;
 
     //! Allocate a specified number of blocks.
     //!
     //! @param count The number of blocks to allocate.
+    //! @param state The state to operate on.
     //! @return A vector of the allocated block numbers.
-    auto allocate_blocks(size_t count) -> kstd::result<kstd::vector<uint32_t>>;
+    auto allocate_blocks(size_t count, mount_state & state) -> kstd::result<kstd::vector<uint32_t>>;
 
     //! Get the size of an inode in the filesystem.
     //!
     //! @return The size of an inode in bytes.
-    [[nodiscard]] auto inode_size() const -> kstd::bytes;
+    [[nodiscard]] auto inode_size(mount_state const & state) const -> kstd::bytes;
 
     //! Get the number of blocks allocated to an inode.
     //!
     //! @param data The inode data.
+    //! @param state The state to operate on.
     //! @return The number of blocks allocated to the inode.
-    [[nodiscard]] auto inode_block_count(inode_data const & data) const -> uint32_t;
+    [[nodiscard]] auto inode_block_count(inode_data const & data, mount_state const & state) const -> uint32_t;
 
     //! Update the number of blocks allocated to an inode.
     //!
     //! @param data The inode data.
+    //! @param state The state to operate on.
     //! @param delta The change in the number of blocks.
-    auto update_inode_block_count(inode_data & data, uint32_t delta) -> void;
+    auto update_inode_block_count(inode_data & data, uint32_t delta, mount_state & state) -> void;
 
     //! Write an inode to the backing inode.
     //!
     //! @param inode_number The number of the inode to write.
+    //! @param state The state to operate on.
     //! @param data The inode data to write.
-    auto write_inode(uint32_t inode_number, inode_data const & data) -> kstd::result<void>;
+    auto write_inode(uint32_t inode_number, inode_data const & data, mount_state & state) -> kstd::result<void>;
 
     //! Map an inode block index to a global block number.
     //!
     //! @param inode_block_index The index of the block within the inode.
+    //! @param state The state to operate on.
     //! @param data The inode data.
     //! @return The global block number on success, an error otherwise.
-    [[nodiscard]] auto map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data) const
+    [[nodiscard]] auto map_inode_block_index_to_global_block_number(size_t inode_block_index, inode_data data,
+                                                                    mount_state const & state) const
         -> kstd::result<std::size_t>;
 
     //! Write a global block number to an inode block index.
     //!
     //! @param block_index The index of the block within the inode.
+    //! @param state The state to operate on.
     //! @param data The inode data.
     //! @param global_block_number The global block number to write.
     auto write_global_block_number_to_inode_block_index(size_t block_index, inode_data & data,
-                                                        uint32_t global_block_number) -> kstd::result<void>;
+                                                        uint32_t global_block_number, mount_state & state)
+        -> kstd::result<void>;
 
     //! Get the backing inode of the file system.
     //!
@@ -166,36 +177,37 @@ namespace kernel::filesystem::ext2
       size_t capacity;
     };
 
-    [[nodiscard]] auto indirect_levels() const -> std::array<indirect_level, 3>;
+    [[nodiscard]] auto indirect_levels(mount_state const & state) const -> std::array<indirect_level, 3>;
 
-    auto allocate_inode() -> kstd::result<uint32_t>;
-    auto add_directory_entry(inode * ext2_parent, std::string_view name, uint32_t child_inode_number, uint16_t mode)
+    auto allocate_inode(mount_state & state) -> kstd::result<uint32_t>;
+    auto add_directory_entry(inode * ext2_parent, std::string_view name, uint32_t child_inode_number, uint16_t mode,
+                             mount_state & state) -> kstd::result<void>;
+    auto init_directory(kstd::shared_ptr<inode> const & new_inode, inode * parent_inode, mount_state & state)
         -> kstd::result<void>;
-    auto init_directory(kstd::shared_ptr<inode> const & new_inode, inode * parent_inode) -> kstd::result<void>;
     auto write_directory_entry_to_buffer(uint8_t * block_buffer, kstd::bytes offset, uint32_t child_inode_number,
-                                         std::string_view name, uint8_t file_type) -> void;
+                                         std::string_view name, uint8_t file_type, mount_state & state) -> void;
 
-    [[nodiscard]] auto calculate_inode_offset(uint32_t inode_number) const -> kstd::result<kstd::bytes>;
-    [[nodiscard]] auto read_inode(uint32_t inode_number) const -> kstd::result<kstd::shared_ptr<inode>>;
-    [[nodiscard]] auto read_block_number_at_index(uint32_t block_number, size_t index) const -> kstd::result<uint32_t>;
+    [[nodiscard]] auto calculate_inode_offset(uint32_t inode_number, mount_state const & state) const
+        -> kstd::result<kstd::bytes>;
+    [[nodiscard]] auto read_inode(uint32_t inode_number, mount_state const & state) const
+        -> kstd::result<kstd::shared_ptr<inode>>;
+    [[nodiscard]] auto read_block_number_at_index(uint32_t block_number, size_t index, mount_state const & state) const
+        -> kstd::result<uint32_t>;
 
-    [[nodiscard]] auto block_group_descriptor_table_offset() const -> kstd::bytes;
+    [[nodiscard]] auto block_group_descriptor_table_offset(mount_state const & state) const -> kstd::bytes;
 
-    [[nodiscard]] auto block_numbers_per_block() const -> size_t;
-    [[nodiscard]] auto block_numbers_per_singly_indirect_block() const -> size_t;
-    [[nodiscard]] auto block_numbers_per_doubly_indirect_block() const -> size_t;
-    [[nodiscard]] auto block_numbers_per_triply_indirect_block() const -> size_t;
+    [[nodiscard]] auto block_numbers_per_block(mount_state const & state) const -> size_t;
+    [[nodiscard]] auto block_numbers_per_singly_indirect_block(mount_state const & state) const -> size_t;
+    [[nodiscard]] auto block_numbers_per_doubly_indirect_block(mount_state const & state) const -> size_t;
+    [[nodiscard]] auto block_numbers_per_triply_indirect_block(mount_state const & state) const -> size_t;
 
     [[nodiscard]] auto write_block_group_descriptor(block_group_descriptor const & block_group_descriptor,
-                                                    size_t block_group_descriptor_index) const -> kstd::result<void>;
-    [[nodiscard]] auto write_superblock() const -> kstd::result<void>;
+                                                    size_t block_group_descriptor_index,
+                                                    mount_state const & state) const -> kstd::result<void>;
+    [[nodiscard]] auto write_superblock(mount_state & state) const -> kstd::result<void>;
 
     auto map_inode_mode_to_file_type(uint16_t mode) -> uint8_t;
     auto map_vfs_inode_type_into_inode_mode(kapi::filesystem::file_type type, uint16_t mode) -> uint16_t;
-
-    superblock m_superblock{};
-    kstd::vector<block_group_descriptor> m_block_group_descriptors;
-    inode_ptr m_backing_inode;
   };
 }  // namespace kernel::filesystem::ext2
 
diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
index 0b815584..752dd010 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
@@ -5,6 +5,7 @@
 #include <kernel/filesystem/ext2/block_group_descriptor.hpp>
 #include <kernel/filesystem/ext2/error.hpp>
 #include <kernel/filesystem/ext2/inode.hpp>
+#include <kernel/filesystem/ext2/mount_state.hpp>
 #include <kernel/filesystem/ext2/superblock.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/mount.hpp>
@@ -207,7 +208,10 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys
     auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
 
     auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    REQUIRE(fs->mount(dev_inode));
+    auto mount = fs->mount(dev_inode);
+    REQUIRE(mount);
+    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>(mount->second);
+    REQUIRE(mount_state);
 
     auto inode_data = kernel::filesystem::ext2::inode_data{};
     inode_data.block[0] = 7;
@@ -231,16 +235,16 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys
 
     THEN("mapping resolves direct, singly, doubly and triply indirect indexes")
     {
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(0, inode_data) == 7);
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(singly_start, inode_data) == 31);
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(doubly_start, inode_data) == 42);
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(triply_start, inode_data) == 53);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(0, inode_data, *mount_state) == 7);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(singly_start, inode_data, *mount_state) == 31);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(doubly_start, inode_data, *mount_state) == 42);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(triply_start, inode_data, *mount_state) == 53);
     }
 
     THEN("mapping returns error for out-of-range indexes")
     {
       auto const beyond_triply = triply_start + numbers_per_block * numbers_per_block * numbers_per_block;
-      REQUIRE(!fs->map_inode_block_index_to_global_block_number(beyond_triply, inode_data));
+      REQUIRE(!fs->map_inode_block_index_to_global_block_number(beyond_triply, inode_data, *mount_state));
     }
   }
 }
@@ -279,7 +283,10 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
     kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock, block_group_descriptor);
 
     auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    REQUIRE(fs->mount(dev_inode));
+    auto mount = fs->mount(dev_inode);
+    REQUIRE(mount);
+    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>(mount->second);
+    REQUIRE(mount_state);
 
     auto read_u32 = [&](kstd::bytes offset) -> uint32_t {
       auto value = uint32_t{0};
@@ -301,26 +308,30 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
       constexpr auto doubly_global_block_number = 303;
       constexpr auto triply_global_block_number = 404;
 
-      REQUIRE(fs->write_global_block_number_to_inode_block_index(0, inode_data, direct_global_block_number));
+      REQUIRE(
+          fs->write_global_block_number_to_inode_block_index(0, inode_data, direct_global_block_number, *mount_state));
       REQUIRE(inode_data.block[0] == direct_global_block_number);
 
-      REQUIRE(fs->write_global_block_number_to_inode_block_index(singly_start, inode_data, singly_global_block_number));
+      REQUIRE(fs->write_global_block_number_to_inode_block_index(singly_start, inode_data, singly_global_block_number,
+                                                                 *mount_state));
       REQUIRE(inode_data.block[12] == 16);
       REQUIRE(read_u32(static_cast<kstd::bytes>(inode_data.block[12]) * block_size.value) ==
               singly_global_block_number);
 
       REQUIRE(fs->write_global_block_number_to_inode_block_index(singly_start + 1, inode_data,
-                                                                 singly_global_block_number + 1));
+                                                                 singly_global_block_number + 1, *mount_state));
       REQUIRE(read_u32(static_cast<kstd::bytes>(inode_data.block[12]) * block_size.value +
                        1 * kstd::size_of<uint32_t>()) == singly_global_block_number + 1);
 
-      REQUIRE(fs->write_global_block_number_to_inode_block_index(doubly_start, inode_data, doubly_global_block_number));
+      REQUIRE(fs->write_global_block_number_to_inode_block_index(doubly_start, inode_data, doubly_global_block_number,
+                                                                 *mount_state));
       REQUIRE(inode_data.block[13] == 17);
       auto const doubly_leaf_table = read_u32(static_cast<size_t>(inode_data.block[13]) * block_size);
       REQUIRE(doubly_leaf_table == 18);
       REQUIRE(read_u32(static_cast<size_t>(doubly_leaf_table) * block_size) == doubly_global_block_number);
 
-      REQUIRE(fs->write_global_block_number_to_inode_block_index(triply_start, inode_data, triply_global_block_number));
+      REQUIRE(fs->write_global_block_number_to_inode_block_index(triply_start, inode_data, triply_global_block_number,
+                                                                 *mount_state));
       REQUIRE(inode_data.block[14] == 19);
       auto const triply_middle_table = read_u32(static_cast<size_t>(inode_data.block[14]) * block_size);
       REQUIRE(triply_middle_table == 20);
@@ -328,10 +339,14 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
       REQUIRE(triply_leaf_table == 21);
       REQUIRE(read_u32(static_cast<size_t>(triply_leaf_table) * block_size) == triply_global_block_number);
 
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(0, inode_data) == direct_global_block_number);
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(singly_start, inode_data) == singly_global_block_number);
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(doubly_start, inode_data) == doubly_global_block_number);
-      REQUIRE(fs->map_inode_block_index_to_global_block_number(triply_start, inode_data) == triply_global_block_number);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(0, inode_data, *mount_state) ==
+              direct_global_block_number);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(singly_start, inode_data, *mount_state) ==
+              singly_global_block_number);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(doubly_start, inode_data, *mount_state) ==
+              doubly_global_block_number);
+      REQUIRE(fs->map_inode_block_index_to_global_block_number(triply_start, inode_data, *mount_state) ==
+              triply_global_block_number);
     }
   }
 }
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
diff --git a/kernel/kernel/filesystem/ext2/inode.hpp b/kernel/kernel/filesystem/ext2/inode.hpp
index cae1d801..6ca2f1b5 100644
--- a/kernel/kernel/filesystem/ext2/inode.hpp
+++ b/kernel/kernel/filesystem/ext2/inode.hpp
@@ -109,6 +109,10 @@ namespace kernel::filesystem::ext2
 
     [[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>>;
+
     //! The inode number on disk.
     uint32_t m_inode_number{};
     //! The inode data.
diff --git a/kernel/kernel/filesystem/ext2/inode.tests.cpp b/kernel/kernel/filesystem/ext2/inode.tests.cpp
index 356e44ed..a6a88fc8 100644
--- a/kernel/kernel/filesystem/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.tests.cpp
@@ -4,6 +4,7 @@
 #include <kernel/filesystem/device_inode.hpp>
 #include <kernel/filesystem/ext2/block_group_descriptor.hpp>
 #include <kernel/filesystem/ext2/filesystem.hpp>
+#include <kernel/filesystem/ext2/mount_state.hpp>
 #include <kernel/filesystem/ext2/superblock.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/mount.hpp>
@@ -326,6 +327,9 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
 
     (*file)->set_owning_mount(*mount);
 
+    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>(driver_data);
+    REQUIRE(mount_state);
+
     THEN("writing to the inode updates backing device and the inode size")
     {
       auto write_buffer = kstd::vector<std::byte>{std::byte{'H'}, std::byte{'e'}, std::byte{'l'}, std::byte{'l'},
@@ -350,8 +354,8 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
     {
       auto inode_data = static_cast<kernel::filesystem::ext2::inode *>(file.value().get())->data();
 
-      auto const block_size = fs->block_size();
-      auto const expected_allocated_blocks = 32 * fs->inode_block_count(inode_data);
+      auto const block_size = fs->block_size(*mount_state);
+      auto const expected_allocated_blocks = 32 * fs->inode_block_count(inode_data, *mount_state);
 
       auto write_buffer = kstd::vector<std::byte>(block_size.value * expected_allocated_blocks, std::byte{'A'});
 
@@ -365,7 +369,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
 
       auto new_inode_data = static_cast<kernel::filesystem::ext2::inode *>(file.value().get())->data();
       REQUIRE(new_inode_data.size == write_buffer.size());
-      REQUIRE(fs->inode_block_count(new_inode_data) == expected_allocated_blocks);
+      REQUIRE(fs->inode_block_count(new_inode_data, *mount_state) == expected_allocated_blocks);
     }
 
     THEN("writing to a an inode of type directory panics")
@@ -413,6 +417,8 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
   auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
   auto root = (*mount)->root_dentry()->inode();
   REQUIRE(mount);
+  auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>((*mount)->driver_data());
+  REQUIRE(mount_state);
 
   auto inode_data = kernel::filesystem::ext2::inode_data{};
   inode_data.size = 5;
@@ -423,7 +429,7 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
 
   uint32_t inode_number = 3;
   auto const inode_data_offset =
-      block_group_descriptor.inode_table * block_size + (inode_number - 1) * fs->inode_size();
+      block_group_descriptor.inode_table * block_size + (inode_number - 1) * fs->inode_size(*mount_state);
 
   auto inode = kernel::filesystem::ext2::inode{inode_number, inode_data};
   inode.set_owning_mount(*mount);
diff --git a/kernel/kernel/filesystem/ext2/mount_state.hpp b/kernel/kernel/filesystem/ext2/mount_state.hpp
index b9c2d5f7..e8ae8fd7 100644
--- a/kernel/kernel/filesystem/ext2/mount_state.hpp
+++ b/kernel/kernel/filesystem/ext2/mount_state.hpp
@@ -13,9 +13,9 @@ namespace kernel::filesystem::ext2
 
   struct mount_state
   {
-    struct superblock superblock;
-    kstd::vector<block_group_descriptor> block_group_descriptors;
-    kstd::shared_ptr<kernel::filesystem::inode> backing_inode;
+    struct superblock superblock{};
+    kstd::vector<block_group_descriptor> block_group_descriptors{};
+    kstd::shared_ptr<kernel::filesystem::inode> backing_inode{};
   };
 
 }  // namespace kernel::filesystem::ext2