1 files changed, 14 insertions, 14 deletions

diff --git a/kernel/kernel/filesystem/ext2/inode.cpp b/kernel/kernel/filesystem/ext2/inode.cpp
index 8e4c2e7c..cba0e70c 100644
--- a/kernel/kernel/filesystem/ext2/inode.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.cpp
@@ -14,6 +14,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <optional>
+#include <span>
 
 using namespace kstd::units_literals;
 
@@ -30,16 +31,15 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto inode::read(void * buffer, kstd::units::bytes offset, kstd::units::bytes size) const
-      -> kstd::result<kstd::units::bytes>
+  auto inode::read(std::span<std::byte> buffer, kstd::units::bytes offset) const -> kstd::result<kstd::units::bytes>
   {
     auto const max_readable = this->size() - offset;
-    auto const requested_size = std::min(size, max_readable);
+    auto const requested_size = std::min(kstd::units::bytes{buffer.size()}, max_readable);
 
     if (is_symbolic_link() && this->size() <= kstd::units::bytes{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.value);
+      kstd::libc::memcpy(buffer.data(), inline_target + offset, requested_size.value);
       return requested_size;
     }
 
@@ -59,15 +59,15 @@ namespace kernel::filesystem::ext2
       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.value);
+        kstd::libc::memset(buffer.data() + bytes_read, 0, bytes_to_read.value);
         bytes_read += bytes_to_read;
       }
       else
       {
         auto const block_start_offset = block_number.value() * m_filesystem->block_size();
         auto const read_offset = block_start_offset + in_block_offset;
-        auto const read_result = m_filesystem->backing_inode()->read(static_cast<uint8_t *>(buffer) + bytes_read,
-                                                                     read_offset, bytes_to_read);
+        auto const read_result =
+            m_filesystem->backing_inode()->read(buffer.subspan(bytes_read.value, bytes_to_read.value), read_offset);
         if (!read_result)
         {
           return kstd::failure(read_result.error());
@@ -83,8 +83,7 @@ namespace kernel::filesystem::ext2
     return bytes_read;
   }
 
-  auto inode::write(void const * buffer, kstd::units::bytes offset, kstd::units::bytes size)
-      -> kstd::result<kstd::units::bytes>
+  auto inode::write(std::span<std::byte const> buffer, kstd::units::bytes offset) -> kstd::result<kstd::units::bytes>
   {
     if (!is_regular())
     {
@@ -94,7 +93,7 @@ namespace kernel::filesystem::ext2
     // TODO check maximum file size of filesystem
     // TODO handle sparse files
 
-    auto const new_inode_size = std::max(this->size(), offset + size);
+    auto const new_inode_size = std::max(this->size(), offset + kstd::units::bytes{buffer.size()});
 
     auto const current_block_count = m_filesystem->inode_block_count(m_data);
     auto const max_new_inode_size_without_new_blocks = current_block_count * m_filesystem->block_size();
@@ -117,7 +116,7 @@ namespace kernel::filesystem::ext2
 
     auto bytes_written = 0_B;
 
-    while (bytes_written < size)
+    while (bytes_written < kstd::units::bytes{buffer.size()})
     {
       auto const block_number = m_filesystem->map_inode_block_index_to_global_block_number(block_index, m_data);
       // TODO BA-FS26 if blocknumber == 0 --> handle sparse file
@@ -126,13 +125,14 @@ namespace kernel::filesystem::ext2
         kstd::failure(block_number.error());
       }
 
-      auto const bytes_to_write = std::min(size - bytes_written, m_filesystem->block_size() - in_block_offset);
+      auto const bytes_to_write =
+          std::min(kstd::units::bytes{buffer.size()} - bytes_written, m_filesystem->block_size() - in_block_offset);
 
       auto const block_start_offset = block_number.value() * m_filesystem->block_size();
       auto const write_offset = block_start_offset + in_block_offset;
 
-      auto const write_result = m_filesystem->backing_inode()->write(
-          static_cast<uint8_t const *>(buffer) + bytes_written, write_offset, bytes_to_write);
+      auto const write_result =
+          m_filesystem->backing_inode()->write(buffer.subspan(bytes_written.value, bytes_to_write.value), write_offset);
       if (!write_result)
       {
         return kstd::failure(write_result.error());