1 files changed, 31 insertions, 29 deletions

diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp
index 893cc38..df5b4c4 100644
--- a/kernel/src/filesystem/ext2/filesystem.cpp
+++ b/kernel/src/filesystem/ext2/filesystem.cpp
@@ -28,14 +28,12 @@ namespace kernel::filesystem::ext2
       return operation_result::invalid_magic_number;
     }
 
-    auto const block_size = get_block_size();
     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;
 
     m_block_group_descriptors = kstd::vector<block_group_descriptor>(num_block_groups);
 
-    auto const block_group_descriptor_table_offset = block_size == 1024 ? 2 * block_size : block_size;
-    m_backing_inode->read(m_block_group_descriptors.data(), block_group_descriptor_table_offset,
+    m_backing_inode->read(m_block_group_descriptors.data(), block_group_descriptor_table_offset(),
                           num_block_groups * sizeof(block_group_descriptor));
 
     m_root_inode = read_inode(constants::root_inode_number);
@@ -47,7 +45,7 @@ namespace kernel::filesystem::ext2
     return operation_result::success;
   }
 
-  auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name)
+  auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name) const
       -> kstd::shared_ptr<kernel::filesystem::inode>
   {
     if (!parent || !parent->is_directory())
@@ -61,20 +59,19 @@ namespace kernel::filesystem::ext2
       return nullptr;
     }
 
-    auto const block_size = get_block_size();
     auto const & inode_data = ext2_parent->data();
-    kstd::vector<uint8_t> buffer(block_size);
+    kstd::vector<uint8_t> buffer(block_size());
 
-    for (uint32_t i = 0; i < get_inode_block_count(inode_data); ++i)
+    for (uint32_t i = 0; i < inode_block_count(inode_data); ++i)
     {
       auto const global_block_number = map_inode_block_index_to_global_block_number(i, inode_data);
-      auto const block_offset = global_block_number * block_size;
-      m_backing_inode->read(buffer.data(), block_offset, block_size);
+      auto const block_offset = global_block_number * block_size();
+      m_backing_inode->read(buffer.data(), block_offset, block_size());
 
       auto const * entry = reinterpret_cast<linked_directory_entry const *>(buffer.data());
       auto bytes_read = 0uz;
 
-      while (bytes_read < block_size && entry->inode != 0)
+      while (bytes_read < block_size() && entry->inode != 0)
       {
         auto const entry_name = std::string_view{entry->name.data(), entry->name_len};
         if (entry_name == name)
@@ -92,7 +89,6 @@ namespace kernel::filesystem::ext2
 
   auto filesystem::read_inode(uint32_t inode_number) const -> kstd::shared_ptr<inode>
   {
-    auto const block_size = get_block_size();
     auto const inodes_per_group = m_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;
@@ -104,8 +100,8 @@ namespace kernel::filesystem::ext2
 
     auto const & block_group_descriptor = m_block_group_descriptors.at(block_group_index);
     auto const inode_table_start_block = block_group_descriptor.inode_table;
-    auto const inode_table_offset = static_cast<size_t>(inode_table_start_block) * block_size;
-    auto const inode_offset = inode_table_offset + inode_index_within_group * get_inode_size();
+    auto const inode_table_offset = static_cast<size_t>(inode_table_start_block) * block_size();
+    auto const inode_offset = inode_table_offset + inode_index_within_group * inode_size();
 
     auto new_inode_data = inode_data{};
     m_backing_inode->read(&new_inode_data, inode_offset, sizeof(inode_data));
@@ -113,7 +109,7 @@ namespace kernel::filesystem::ext2
     return kstd::make_shared<inode>(this, new_inode_data);
   }
 
-  auto filesystem::map_inode_block_index_to_global_block_number(uint32_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) const
       -> ssize_t
   {
     if (inode_block_index < constants::direct_block_count)
@@ -146,17 +142,18 @@ namespace kernel::filesystem::ext2
   }
 
   auto filesystem::read_singly_indirect_block_number(uint32_t singly_indirect_block_number,
-                                                     uint32_t block_index_in_singly_indirect_block) const -> uint32_t
+                                                     size_t block_index_in_singly_indirect_block) const -> size_t
   {
     if (singly_indirect_block_number == 0)
     {
       return 0;
     }
+
     return read_block_number_at_index(singly_indirect_block_number, block_index_in_singly_indirect_block);
   }
 
   auto filesystem::read_doubly_indirect_block_number(uint32_t doubly_indirect_block_number,
-                                                     uint32_t block_index_in_doubly_indirect_block) const -> uint32_t
+                                                     size_t block_index_in_doubly_indirect_block) const -> size_t
   {
     if (doubly_indirect_block_number == 0)
     {
@@ -175,7 +172,7 @@ namespace kernel::filesystem::ext2
   }
 
   auto filesystem::read_triply_indirect_block_number(uint32_t triply_indirect_block_number,
-                                                     uint32_t block_index_in_triply_indirect_block) const -> uint32_t
+                                                     size_t block_index_in_triply_indirect_block) const -> size_t
   {
     if (triply_indirect_block_number == 0)
     {
@@ -193,54 +190,59 @@ namespace kernel::filesystem::ext2
     return read_doubly_indirect_block_number(doubly_indirect_block_number, block_index_in_doubly_indirect_block);
   }
 
-  auto filesystem::read_block_number_at_index(uint32_t block_number, uint32_t index) const -> uint32_t
+  auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t
   {
     uint32_t block_number_buffer = 0;
 
-    auto const block_start_offset = block_number * get_block_size();
+    auto const block_start_offset = block_number * block_size();
     auto const number_start_address = block_start_offset + index * sizeof(uint32_t);
     m_backing_inode->read(&block_number_buffer, number_start_address, sizeof(uint32_t));
 
     return block_number_buffer;
   }
 
-  auto filesystem::block_numbers_per_block() const -> uint32_t
+  auto filesystem::block_numbers_per_block() const -> size_t
   {
-    return get_block_size() / sizeof(uint32_t);
+    return block_size() / sizeof(uint32_t);
   }
 
-  auto filesystem::block_numbers_per_singly_indirect_block() const -> uint32_t
+  auto filesystem::block_numbers_per_singly_indirect_block() const -> size_t
   {
     return block_numbers_per_block();
   }
 
-  auto filesystem::block_numbers_per_doubly_indirect_block() const -> uint32_t
+  auto filesystem::block_numbers_per_doubly_indirect_block() const -> size_t
   {
     return block_numbers_per_singly_indirect_block() * block_numbers_per_block();
   }
 
-  auto filesystem::block_numbers_per_triply_indirect_block() const -> uint32_t
+  auto filesystem::block_numbers_per_triply_indirect_block() const -> size_t
   {
     return block_numbers_per_doubly_indirect_block() * block_numbers_per_block();
   }
 
-  auto filesystem::get_block_size() const -> size_t
+  auto filesystem::block_size() const -> size_t
   {
     return constants::base_block_size << m_superblock.log_block_size;
   }
 
-  auto filesystem::get_revision_level() const -> size_t
+  auto filesystem::revision_level() const -> uint32_t
   {
     return m_superblock.rev_level;
   }
 
-  auto filesystem::get_inode_size() const -> size_t
+  auto filesystem::inode_size() const -> uint16_t
   {
-    return get_revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size;
+    return revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size;
   }
 
-  auto filesystem::get_inode_block_count(inode_data const & data) const -> uint32_t
+  auto filesystem::inode_block_count(inode_data const & data) const -> uint32_t
   {
     return data.blocks / (2 << m_superblock.log_block_size);
   }
+
+  auto filesystem::block_group_descriptor_table_offset() const -> size_t
+  {
+    return block_size() == 1024 ? 2 * block_size() : block_size();
+  }
 }  // namespace kernel::filesystem::ext2