Merge branch 'ext2' into 'develop-BA-FS26'

Ext2-initial-structure

See merge request teachos/kernel!17

4 files changed, 141 insertions, 93 deletions

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_file.cpp b/kernel/src/filesystem/ext2/ext2_file.cpp
deleted file mode 100644
index 7217c77..0000000
--- a/kernel/src/filesystem/ext2/ext2_file.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "kernel/filesystem/ext2/ext2_file.hpp"
-
-#include "kapi/system.hpp"
-
-#include <cstddef>
-
-namespace filesystem::ext2
-{
-  auto ext2_file::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
-  {
-    kapi::system::panic("[FILESYSTEM] ext2_file::read is not implemented yet.");
-    return 0;
-  }
-
-  auto ext2_file::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
-  {
-    kapi::system::panic("[FILESYSTEM] ext2_file::write is not implemented yet.");
-    return 0;
-  }
-}  // namespace filesystem::ext2
diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp
index 373c6a2..ea6fe0d 100644
--- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp
+++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp
@@ -1,16 +1,50 @@
 #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/ext2/ext2_superblock.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/inode.hpp"
 
 #include <kstd/memory>
 
+#include <cstddef>
+#include <cstdint>
 #include <string_view>
 
 namespace filesystem::ext2
 {
+  namespace
+  {
+    // constexpr size_t SUPERBLOCK_OFFSET = 1024;
+    // constexpr uint16_t EXT2_MAGIC = 0xEF53;
+
+    // // Mode bits
+    // constexpr uint16_t S_IFMT = 0xF000;
+    // constexpr uint16_t S_IFREG = 0x8000;
+    // constexpr uint16_t S_IFDIR = 0x4000;
+
+    // auto S_ISREG(uint16_t mode) -> bool
+    // {
+    //   return (mode & S_IFMT) == S_IFREG;
+    // }
+    // auto S_ISDIR(uint16_t mode) -> bool
+    // {
+    //   return (mode & S_IFMT) == S_IFDIR;
+    // }
+
+    // auto get_block_size(ext2_superblock const & superblock) -> size_t
+    // {
+    //   return 1024U << superblock.log_block_size;
+    // }
+
+    // auto get_inode_size(ext2_superblock const & superblock) -> size_t
+    // {
+    //   return superblock.rev_level == 0 ? 128 : superblock.inode_size;
+    // }
+  }  // namespace
+
   auto ext2_filesystem::mount(kstd::shared_ptr<devices::device> const & device) -> int
   {
     filesystem::mount(device);  // TODO BA-FS26 error handling?
@@ -19,6 +53,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;
   }