refactoring

3 files changed, 49 insertions, 48 deletions

diff --git a/kernel/src/filesystem/ext2/filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp
index 893cc38..7633972 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 (auto i = 0uz; 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)
@@ -90,9 +87,8 @@ namespace kernel::filesystem::ext2
     return nullptr;
   }
 
-  auto filesystem::read_inode(uint32_t inode_number) const -> kstd::shared_ptr<inode>
+  auto filesystem::read_inode(size_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)
@@ -145,18 +141,19 @@ namespace kernel::filesystem::ext2
     return -1;
   }
 
-  auto filesystem::read_singly_indirect_block_number(uint32_t singly_indirect_block_number,
-                                                     uint32_t block_index_in_singly_indirect_block) const -> uint32_t
+  auto filesystem::read_singly_indirect_block_number(size_t singly_indirect_block_number,
+                                                     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
+  auto filesystem::read_doubly_indirect_block_number(size_t doubly_indirect_block_number,
+                                                     size_t block_index_in_doubly_indirect_block) const -> size_t
   {
     if (doubly_indirect_block_number == 0)
     {
@@ -174,8 +171,8 @@ namespace kernel::filesystem::ext2
     return read_singly_indirect_block_number(singly_indirect_block_number, block_index_in_singly_indirect_block);
   }
 
-  auto filesystem::read_triply_indirect_block_number(uint32_t triply_indirect_block_number,
-                                                     uint32_t block_index_in_triply_indirect_block) const -> uint32_t
+  auto filesystem::read_triply_indirect_block_number(size_t triply_indirect_block_number,
+                                                     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(size_t block_number, size_t index) const -> size_t
   {
-    uint32_t block_number_buffer = 0;
+    auto block_number_buffer = 0uz;
 
-    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 -> size_t
   {
     return m_superblock.rev_level;
   }
 
-  auto filesystem::get_inode_size() const -> size_t
+  auto filesystem::inode_size() const -> size_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 -> size_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
diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp
index cfe0a35..f8c818c 100644
--- a/kernel/src/filesystem/ext2/inode.cpp
+++ b/kernel/src/filesystem/ext2/inode.cpp
@@ -25,18 +25,18 @@ namespace kernel::filesystem::ext2
 
   auto inode::read(void * buffer, size_t offset, size_t size) const -> size_t
   {
-    auto const max_readable = get_size() - offset;
+    auto const max_readable = this->size() - offset;
     auto const requested_size = std::min(size, max_readable);
 
-    if (is_symbolic_link() && get_size() <= sizeof(m_data.block))
+    if (is_symbolic_link() && this->size() <= sizeof(m_data.block))
     {
       auto inline_target = reinterpret_cast<uint8_t const *>(m_data.block.data());
       kstd::libc::memcpy(static_cast<uint8_t *>(buffer), inline_target + offset, requested_size);
       return requested_size;
     }
 
-    auto block_index = offset / m_filesystem->get_block_size();
-    auto in_block_offset = offset % m_filesystem->get_block_size();
+    auto block_index = offset / m_filesystem->block_size();
+    auto in_block_offset = offset % m_filesystem->block_size();
 
     auto bytes_read = 0uz;
 
@@ -48,8 +48,7 @@ namespace kernel::filesystem::ext2
         break;
       }
 
-      auto const bytes_to_read =
-          std::min(requested_size - bytes_read, m_filesystem->get_block_size() - in_block_offset);
+      auto const bytes_to_read = std::min(requested_size - bytes_read, m_filesystem->block_size() - in_block_offset);
       if (block_number == 0)
       {
         kstd::libc::memset(static_cast<uint8_t *>(buffer) + bytes_read, 0, bytes_to_read);
@@ -57,7 +56,7 @@ namespace kernel::filesystem::ext2
       }
       else
       {
-        auto const block_start_offset = block_number * m_filesystem->get_block_size();
+        auto const block_start_offset = block_number * m_filesystem->block_size();
         auto const read_offset = block_start_offset + in_block_offset;
 
         bytes_read += m_filesystem->backing_inode()->read(static_cast<uint8_t *>(buffer) + bytes_read, read_offset,
@@ -71,7 +70,7 @@ namespace kernel::filesystem::ext2
     return bytes_read;
   }
 
-  auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
+  auto inode::write(void const *, size_t, size_t) -> size_t
   {
     kapi::system::panic("[EXT2] inode::write is not implemented yet");
     return 0;
@@ -97,11 +96,11 @@ namespace kernel::filesystem::ext2
     return (m_data.mode & constants::mode_mask) == constants::mode_symbolic_link;
   }
 
-  auto inode::get_size() const -> size_t
+  auto inode::size() const -> size_t
   {
     uint64_t size = m_data.size;
 
-    if (m_filesystem->get_revision_level() > constants::good_old_revision && is_regular())
+    if (m_filesystem->revision_level() > constants::good_old_revision && is_regular())
     {
       size |= static_cast<uint64_t>(m_data.dir_acl) << 32;
     }
diff --git a/kernel/src/filesystem/ext2/inode.tests.cpp b/kernel/src/filesystem/ext2/inode.tests.cpp
index efc0660..4aecc04 100644
--- a/kernel/src/filesystem/ext2/inode.tests.cpp
+++ b/kernel/src/filesystem/ext2/inode.tests.cpp
@@ -325,7 +325,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev
 
       auto inode = kernel::filesystem::ext2::inode{&fs, data};
 
-      REQUIRE(inode.get_size() == 256);
+      REQUIRE(inode.size() == 256);
     }
 
     THEN("the inode size is 256 if mode = directory")
@@ -334,7 +334,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev
 
       auto inode = kernel::filesystem::ext2::inode{&fs, data};
 
-      REQUIRE(inode.get_size() == 256);
+      REQUIRE(inode.size() == 256);
     }
   }
 
@@ -361,7 +361,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev
 
       auto inode = kernel::filesystem::ext2::inode{&fs, data};
 
-      REQUIRE(inode.get_size() == 0x0000'0020'0000'0100);
+      REQUIRE(inode.size() == 0x0000'0020'0000'0100);
     }
 
     THEN("the inode size is 256 if mode = directory")
@@ -370,7 +370,7 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev
 
       auto inode = kernel::filesystem::ext2::inode{&fs, data};
 
-      REQUIRE(inode.get_size() == 256);
+      REQUIRE(inode.size() == 256);
     }
   }
 }
\ No newline at end of file