Move block device offset and size-to-blocks calculation to block_device_utils

6 files changed, 126 insertions, 78 deletions

diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
index 1a8eb99..5f9a019 100644
--- a/kernel/CMakeLists.txt
+++ b/kernel/CMakeLists.txt
@@ -17,6 +17,7 @@ add_executable("kernel"
     "src/memory.cpp"
     "src/devices/device.cpp"
     "src/devices/block_device.cpp"
+    "src/devices/block_device_utils.cpp"
     "src/devices/storage/storage_controller.cpp"
     "src/devices/storage/storage_management.cpp"
     "src/devices/storage/ram_disk/ram_disk_controller.cpp"
diff --git a/kernel/include/kernel/devices/block_device_utils.hpp b/kernel/include/kernel/devices/block_device_utils.hpp
new file mode 100644
index 0000000..5ec69d1
--- /dev/null
+++ b/kernel/include/kernel/devices/block_device_utils.hpp
@@ -0,0 +1,17 @@
+#ifndef TEACH_OS_KERNEL_DEVICES_BLOCK_DEVICE_UTILS_HPP
+#define TEACH_OS_KERNEL_DEVICES_BLOCK_DEVICE_UTILS_HPP
+
+#include "kernel/devices/device.hpp"
+
+#include <kstd/memory>
+
+#include <cstddef>
+
+namespace devices::block_device_utils
+{
+  auto read(kstd::shared_ptr<devices::device> const & device, void * buffer, size_t offset, size_t size) -> size_t;
+  auto write(kstd::shared_ptr<devices::device> const & device, void const * buffer, size_t offset, size_t size)
+      -> size_t;
+}  // namespace devices::block_device_utils
+
+#endif
\ No newline at end of file
diff --git a/kernel/include/kernel/filesystem/device_inode.hpp b/kernel/include/kernel/filesystem/device_inode.hpp
index 1cf08d4..0477969 100644
--- a/kernel/include/kernel/filesystem/device_inode.hpp
+++ b/kernel/include/kernel/filesystem/device_inode.hpp
@@ -1,7 +1,6 @@
 #ifndef TEACH_OS_KERNEL_FILESYSTEM_DEVICE_INODE_HPP
 #define TEACH_OS_KERNEL_FILESYSTEM_DEVICE_INODE_HPP
 
-#include "kernel/devices/block_device.hpp"
 #include "kernel/devices/device.hpp"
 #include "kernel/filesystem/inode.hpp"
 
@@ -21,10 +20,6 @@ namespace filesystem
     [[nodiscard]] auto device() const -> kstd::shared_ptr<devices::device> const &;
 
   private:
-    using block_op = void (*)(size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
-                              std::byte * scratch, void * buffer);
-    auto process_blocks(size_t offset, size_t size, void * buffer, block_op op) const -> size_t;
-
     kstd::shared_ptr<devices::device> m_device;
   };
 }  // namespace filesystem
diff --git a/kernel/src/devices/block_device_utils.cpp b/kernel/src/devices/block_device_utils.cpp
new file mode 100644
index 0000000..9d3af1b
--- /dev/null
+++ b/kernel/src/devices/block_device_utils.cpp
@@ -0,0 +1,103 @@
+#include "kernel/devices/block_device_utils.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/devices/block_device.hpp"
+#include "kernel/devices/device.hpp"
+
+#include <kstd/cstring>
+#include <kstd/memory>
+#include <kstd/vector>
+
+#include <algorithm>
+#include <cstddef>
+
+namespace devices::block_device_utils
+{
+
+  using block_op = void (*)(size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
+                            std::byte * scratch, void * buffer);
+
+  auto process_blocks(kstd::shared_ptr<devices::device> const & device, size_t offset, size_t size, void * buffer,
+                      block_op op) -> size_t
+  {
+    if (buffer == nullptr)
+    {
+      kapi::system::panic("[FILESYSTEM] device_file::process_blocks called with null buffer.");
+    }
+
+    if (size == 0)
+    {
+      return 0;
+    }
+
+    auto * block_dev = static_cast<devices::block_device *>(device.get());
+    if (block_dev == nullptr)
+    {
+      kapi::system::panic("[FILESYSTEM] device_file: expected block_device.");
+    }
+
+    size_t const block_size = block_dev->block_size();
+    size_t const capacity = block_dev->capacity();
+
+    if (offset >= capacity)
+      return 0;
+    size_t const total_to_process = std::min(size, capacity - offset);
+
+    kstd::vector<std::byte> scratch_buffer{block_size};
+    auto processed = 0uz;
+
+    while (processed < total_to_process)
+    {
+      size_t const absolute_offset = offset + processed;
+      size_t const block_index = absolute_offset / block_size;
+      size_t const in_block_offset = absolute_offset % block_size;
+      size_t const chunk_size = std::min(total_to_process - processed, block_size - in_block_offset);
+
+      op(block_index, in_block_offset, chunk_size, processed, block_dev, scratch_buffer.data(), buffer);
+
+      processed += chunk_size;
+    }
+
+    return processed;
+  }
+
+  auto read(kstd::shared_ptr<devices::device> const & device, void * buffer, size_t offset, size_t size) -> size_t
+  {
+    return process_blocks(device, offset, size, buffer,
+                          [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
+                             std::byte * scratch, void * buffer) {
+                            auto * out = static_cast<std::byte *>(buffer);
+                            if (off == 0 && len == device->block_size())
+                            {
+                              device->read_block(idx, out + done);
+                            }
+                            else
+                            {
+                              device->read_block(idx, scratch);
+                              kstd::libc::memcpy(out + done, scratch + off, len);
+                            }
+                          });
+  }
+
+  auto write(kstd::shared_ptr<devices::device> const & device, void const * buffer, size_t offset, size_t size)
+      -> size_t
+  {
+    return process_blocks(device, offset, size, const_cast<void *>(buffer),
+                          [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
+                             std::byte * scratch, void * buffer) {
+                            auto const * in = static_cast<std::byte const *>(buffer);
+                            if (off == 0 && len == device->block_size())
+                            {
+                              device->write_block(idx, in + done);
+                            }
+                            else
+                            {
+                              device->read_block(idx, scratch);
+                              kstd::libc::memcpy(scratch + off, in + done, len);
+                              device->write_block(idx, scratch);
+                            }
+                          });
+  }
+
+}  // namespace devices::block_device_utils
\ No newline at end of file
diff --git a/kernel/src/filesystem/device_inode.cpp b/kernel/src/filesystem/device_inode.cpp
index 64cd6e9..da062fc 100644
--- a/kernel/src/filesystem/device_inode.cpp
+++ b/kernel/src/filesystem/device_inode.cpp
@@ -2,7 +2,7 @@
 
 #include "kapi/system.hpp"
 
-#include "kernel/devices/block_device.hpp"
+#include "kernel/devices/block_device_utils.hpp"
 #include "kernel/devices/device.hpp"
 #include "kernel/filesystem/inode.hpp"
 
@@ -10,7 +10,6 @@
 #include <kstd/memory>
 #include <kstd/vector>
 
-#include <algorithm>
 #include <cstddef>
 
 namespace filesystem
@@ -29,20 +28,7 @@ namespace filesystem
   {
     if (m_device->is_block_device())
     {
-      return process_blocks(offset, size, buffer,
-                            [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
-                               std::byte * scratch, void * buffer) {
-                              auto * out = static_cast<std::byte *>(buffer);
-                              if (off == 0 && len == device->block_size())
-                              {
-                                device->read_block(idx, out + done);
-                              }
-                              else
-                              {
-                                device->read_block(idx, scratch);
-                                kstd::libc::memcpy(out + done, scratch + off, len);
-                              }
-                            });
+      return devices::block_device_utils::read(m_device, buffer, offset, size);
     }
     else
     {
@@ -54,21 +40,7 @@ namespace filesystem
   {
     if (m_device->is_block_device())
     {
-      return process_blocks(offset, size, const_cast<void *>(buffer),
-                            [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
-                               std::byte * scratch, void * buffer) {
-                              auto const * in = static_cast<std::byte const *>(buffer);
-                              if (off == 0 && len == device->block_size())
-                              {
-                                device->write_block(idx, in + done);
-                              }
-                              else
-                              {
-                                device->read_block(idx, scratch);
-                                kstd::libc::memcpy(scratch + off, in + done, len);
-                                device->write_block(idx, scratch);
-                              }
-                            });
+      return devices::block_device_utils::write(m_device, buffer, offset, size);
     }
     else
     {
@@ -81,46 +53,4 @@ namespace filesystem
     return m_device;
   }
 
-  auto device_inode::process_blocks(size_t offset, size_t size, void * buffer, block_op op) const -> size_t
-  {
-    if (buffer == nullptr)
-    {
-      kapi::system::panic("[FILESYSTEM] device_file::process_blocks called with null buffer.");
-    }
-
-    if (size == 0)
-    {
-      return 0;
-    }
-
-    auto * block_dev = static_cast<devices::block_device *>(m_device.get());
-    if (block_dev == nullptr)
-    {
-      kapi::system::panic("[FILESYSTEM] device_file: expected block_device.");
-    }
-
-    size_t const block_size = block_dev->block_size();
-    size_t const capacity = block_dev->capacity();
-
-    if (offset >= capacity)
-      return 0;
-    size_t const total_to_process = std::min(size, capacity - offset);
-
-    kstd::vector<std::byte> scratch_buffer{block_size};
-    auto processed = 0uz;
-
-    while (processed < total_to_process)
-    {
-      size_t const absolute_offset = offset + processed;
-      size_t const block_index = absolute_offset / block_size;
-      size_t const in_block_offset = absolute_offset % block_size;
-      size_t const chunk_size = std::min(total_to_process - processed, block_size - in_block_offset);
-
-      op(block_index, in_block_offset, chunk_size, processed, block_dev, scratch_buffer.data(), buffer);
-
-      processed += chunk_size;
-    }
-
-    return processed;
-  }
 }  // namespace filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp
index 373c6a2..19f1014 100644
--- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp
+++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp
@@ -1,5 +1,6 @@
 #include "kernel/filesystem/ext2/ext2_filesystem.hpp"
 
+#include "kernel/devices/block_device_utils.hpp"
 #include "kernel/devices/device.hpp"
 #include "kernel/filesystem/ext2/ext2_inode.hpp"
 #include "kernel/filesystem/filesystem.hpp"
@@ -19,6 +20,7 @@ namespace filesystem::ext2
 
     // TODO BA-FS26 implement
     m_root_inode = kstd::make_shared<ext2_inode>();
+    // devices::block_device_utils::read(device, nullptr, 0, 0);  // TODO BA-FS26 just for testing
     return 0;
   }