use kstd::vector instead of std::array and replace plain-pointers with kstd::shared_ptr

10 files changed, 62 insertions, 60 deletions

diff --git a/kernel/filesystem/src/custody.cpp b/kernel/filesystem/src/custody.cpp
index 614e63b..7a58229 100644
--- a/kernel/filesystem/src/custody.cpp
+++ b/kernel/filesystem/src/custody.cpp
@@ -4,9 +4,11 @@
 
 #include "filesystem/inode.hpp"
 
+#include <kstd/memory>
+
 namespace filesystem
 {
-  custody::custody(custody * parent, inode * node)
+  custody::custody(kstd::shared_ptr<custody> parent, kstd::shared_ptr<inode> node)
       : m_parent(parent)
       , m_inode(node)
   {
@@ -16,12 +18,12 @@ namespace filesystem
     }
   }
 
-  auto custody::get_inode() const -> inode *
+  auto custody::get_inode() const -> kstd::shared_ptr<inode>
   {
     return m_inode;
   }
 
-  auto custody::get_parent() const -> custody *
+  auto custody::get_parent() const -> kstd::shared_ptr<custody>
   {
     return m_parent;
   }
diff --git a/kernel/filesystem/src/device_file.cpp b/kernel/filesystem/src/device_file.cpp
index f11638e..882c9b1 100644
--- a/kernel/filesystem/src/device_file.cpp
+++ b/kernel/filesystem/src/device_file.cpp
@@ -6,14 +6,15 @@
 #include "devices/device.hpp"
 
 #include <kstd/cstring>
+#include <kstd/memory>
+#include <kstd/vector>
 
 #include <algorithm>
-#include <array>
 #include <cstddef>
 
 namespace filesystem
 {
-  device_file::device_file(devices::device * device)
+  device_file::device_file(kstd::shared_ptr<devices::device> device)
       : m_device(device)
   {
     if (!m_device)
@@ -90,7 +91,13 @@ namespace filesystem
       return 0;
     }
 
-    auto * block_dev = static_cast<devices::block_device *>(m_device);
+    // @Felix rtti not activated why? e.g. dynamic_cast does not work, whats with std::dynamic_pointer_cast
+    // online: rtti overhead, bad design, ... ?
+    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();
@@ -99,8 +106,7 @@ namespace filesystem
       return 0;
     size_t const total_to_process = std::min(size, capacity - offset);
 
-    // TODO BA-FS26 use kstd::vector when available
-    std::array<std::byte, 512> scratch_buffer{};  // TODO BA-FS26 better solution than fixed scratch_buffer ??
+    kstd::vector<std::byte> scratch_buffer{block_size};
     auto processed = 0uz;
 
     while (processed < total_to_process)
diff --git a/kernel/filesystem/src/ext2/ext2_filesystem.cpp b/kernel/filesystem/src/ext2/ext2_filesystem.cpp
index f092ddf..2ae5ab7 100644
--- a/kernel/filesystem/src/ext2/ext2_filesystem.cpp
+++ b/kernel/filesystem/src/ext2/ext2_filesystem.cpp
@@ -2,12 +2,15 @@
 
 #include "devices/device.hpp"
 #include "filesystem/inode.hpp"
+#include "filesystem/inode_metadata.hpp"
+
+#include <kstd/memory>
 
 #include <string_view>
 
 namespace filesystem::ext2
 {
-  auto ext2_filesystem::mount(devices::device * device) -> int
+  auto ext2_filesystem::mount(kstd::shared_ptr<devices::device> device) -> int
   {
     if (!device)
     {
diff --git a/kernel/filesystem/src/file_descriptor_table.cpp b/kernel/filesystem/src/file_descriptor_table.cpp
index eb9a281..64fad0c 100644
--- a/kernel/filesystem/src/file_descriptor_table.cpp
+++ b/kernel/filesystem/src/file_descriptor_table.cpp
@@ -44,7 +44,8 @@ namespace filesystem
       return static_cast<int>(it - m_open_files.begin());
     }
 
-    return -1;
+    m_open_files.push_back(file_description);
+    return static_cast<int>(m_open_files.size() - 1);
   }
 
   auto file_descriptor_table::get_file(int fd) const -> std::optional<open_file_description>
@@ -55,12 +56,12 @@ namespace filesystem
     }
 
     auto const index = static_cast<size_t>(fd);
-    if (index >= m_open_files.size() || !m_open_files[index].has_value())
+    if (index >= m_open_files.size() || !m_open_files.at(fd).has_value())
     {
       return std::nullopt;
     }
 
-    return *m_open_files[index];
+    return m_open_files.at(fd);
   }
 
   auto file_descriptor_table::remove_file(int fd) -> void
@@ -76,6 +77,6 @@ namespace filesystem
       return;
     }
 
-    m_open_files[index].reset();
+    m_open_files.at(fd).reset();
   }
 }  // namespace filesystem
\ No newline at end of file
diff --git a/kernel/filesystem/src/filesystem.cpp b/kernel/filesystem/src/filesystem.cpp
index a06bccc..cdfe7f8 100644
--- a/kernel/filesystem/src/filesystem.cpp
+++ b/kernel/filesystem/src/filesystem.cpp
@@ -4,13 +4,8 @@
 
 namespace filesystem
 {
-  auto filesystem::root_inode() -> inode *
+  auto filesystem::root_inode() const -> inode const &
   {
-    return &m_root_inode;
-  }
-
-  auto filesystem::root_inode() const -> inode const *
-  {
-    return &m_root_inode;
+    return m_root_inode;
   }
 }  // namespace filesystem
\ No newline at end of file
diff --git a/kernel/filesystem/src/inode.cpp b/kernel/filesystem/src/inode.cpp
index 17aa52a..10a9a30 100644
--- a/kernel/filesystem/src/inode.cpp
+++ b/kernel/filesystem/src/inode.cpp
@@ -5,6 +5,8 @@
 #include "devices/device.hpp"
 #include "filesystem/inode_metadata.hpp"
 
+#include <kstd/memory>
+
 #include <cstddef>
 
 namespace filesystem
@@ -13,7 +15,7 @@ namespace filesystem
       : m_kind(kind)
   {}
 
-  inode::inode(devices::device * device)
+  inode::inode(kstd::shared_ptr<devices::device> device)
       : m_kind(inode_kind::device)
       , m_device(device)
   {
@@ -77,7 +79,7 @@ namespace filesystem
     return m_device->minor();
   }
 
-  auto inode::backing_device() const -> devices::device *
+  auto inode::backing_device() const -> kstd::shared_ptr<devices::device>
   {
     return m_device;
   }
diff --git a/kernel/filesystem/src/inode_file.cpp b/kernel/filesystem/src/inode_file.cpp
index 071661f..b68b3ee 100644
--- a/kernel/filesystem/src/inode_file.cpp
+++ b/kernel/filesystem/src/inode_file.cpp
@@ -4,11 +4,13 @@
 
 #include "filesystem/inode.hpp"
 
+#include <kstd/memory>
+
 #include <cstddef>
 
 namespace filesystem
 {
-  inode_file::inode_file(inode * inode)
+  inode_file::inode_file(kstd::shared_ptr<inode> inode)
       : m_inode(inode)
   {
     if (!m_inode)
diff --git a/kernel/filesystem/src/mount.cpp b/kernel/filesystem/src/mount.cpp
index 6594598..53a8143 100644
--- a/kernel/filesystem/src/mount.cpp
+++ b/kernel/filesystem/src/mount.cpp
@@ -4,11 +4,13 @@
 
 #include "filesystem/filesystem.hpp"
 
+#include <kstd/memory>
+
 #include <string_view>
 
 namespace filesystem
 {
-  mount::mount(std::string_view const & path, filesystem * fs)
+  mount::mount(std::string_view const & path, kstd::shared_ptr<filesystem> fs)
       : m_path(path)
       , m_filesystem(fs)
   {
@@ -23,7 +25,7 @@ namespace filesystem
     return m_path;
   }
 
-  auto mount::get_filesystem() const -> filesystem *
+  auto mount::get_filesystem() const -> kstd::shared_ptr<filesystem>
   {
     return m_filesystem;
   }
diff --git a/kernel/filesystem/src/open_file_description.cpp b/kernel/filesystem/src/open_file_description.cpp
index d483746..9ebf67d 100644
--- a/kernel/filesystem/src/open_file_description.cpp
+++ b/kernel/filesystem/src/open_file_description.cpp
@@ -2,18 +2,25 @@
 
 #include "filesystem/file.hpp"
 
+#include <kstd/memory>
+#include <kstd/os/error.hpp>
+
 #include <cstddef>
 
 namespace filesystem
 {
-  open_file_description::open_file_description(file * file)
+  open_file_description::open_file_description(kstd::shared_ptr<file> file)
       : m_file(file)
       , m_offset(0)
-  {}
+  {
+    if (!file)
+    {
+      kstd::os::panic("[FILESYSTEM] open_file_description constructed with null file.");
+    }
+  }
 
   auto open_file_description::read(void * buffer, size_t size) -> size_t
   {
-    // TODO BA-FS26 nullptr check
     auto read_bytes = m_file->read(buffer, m_offset, size);
     m_offset += read_bytes;
     return read_bytes;
@@ -21,7 +28,6 @@ namespace filesystem
 
   auto open_file_description::write(void const * buffer, size_t size) -> size_t
   {
-    // TODO BA-FS26 nullptr check
     auto written_bytes = m_file->write(buffer, m_offset, size);
     m_offset += written_bytes;
     return written_bytes;
diff --git a/kernel/filesystem/src/vfs.cpp b/kernel/filesystem/src/vfs.cpp
index 2ecf847..578fde4 100644
--- a/kernel/filesystem/src/vfs.cpp
+++ b/kernel/filesystem/src/vfs.cpp
@@ -13,6 +13,7 @@
 #include "filesystem/open_file_description.hpp"
 
 #include <kstd/cstring>
+#include <kstd/memory>
 
 #include <algorithm>
 #include <optional>
@@ -23,15 +24,6 @@ namespace filesystem
   namespace
   {
     constinit auto static active_vfs = std::optional<vfs>{};
-
-    // TODO BA-FS26 @Felix better solution? while dynamic memory not available?
-    // TODO BA-FS26 remove when dynamic memory available;
-    constinit auto static root_fs = std::optional<ext2::ext2_filesystem>{};
-
-    // TODO BA-FS26 remove when dynamic memory available;
-    constinit auto static temp_device_file = std::optional<device_file>{};
-    // TODO BA-FS26 remove when dynamic memory available;
-    constinit auto static temp_inode_file = std::optional<inode_file>{};
   }  // namespace
 
   auto vfs::init() -> void
@@ -46,13 +38,13 @@ namespace filesystem
     auto storage_mgmt = devices::storage::storage_management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
-      root_fs.emplace(ext2::ext2_filesystem{});
-      if (root_fs->mount(boot_device) != 0)
+      active_vfs->m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
+      if (active_vfs->m_root_fs->mount(boot_device) != 0)
       {
         kapi::system::panic("[FILESYSTEM] Failed to mount root filesystem.");
       }
 
-      active_vfs->m_root_mount = mount{"/", &*root_fs};
+      active_vfs->m_root_mount = mount{"/", active_vfs->m_root_fs};
 
       std::ranges::for_each(storage_mgmt.all_controllers(), [&](auto controller) {
         std::ranges::for_each(controller->all_devices(), [&](auto device) { active_vfs->make_device_node(device); });
@@ -78,39 +70,30 @@ namespace filesystem
   {
     if (auto custody = resolve_path(path))
     {
-      auto * node = custody->get_inode();
+      auto node = custody->get_inode();
       if (node->is_device())
       {
-        temp_device_file.emplace(node->backing_device());
-        temp_device_file->open();
-        return open_file_description{&*temp_device_file};
+        auto current_device_file = kstd::make_shared<device_file>(node->backing_device());
+        current_device_file->open();
+        return open_file_description{current_device_file};
       }
 
-      temp_inode_file.emplace(node);
-      temp_inode_file->open();
-      return open_file_description{&*temp_inode_file};
+      auto current_inode_file = kstd::make_shared<inode_file>(node);
+      current_inode_file->open();
+      return open_file_description{current_inode_file};
     }
 
     return std::nullopt;
   }
 
-  auto vfs::make_device_node(devices::device * device) -> void
+  auto vfs::make_device_node(kstd::shared_ptr<devices::device> device) -> void
   {
     if (!device)
     {
       kapi::system::panic("[FILESYSTEM] make_device_node called with null device.");
     }
 
-    auto const device_name = device->name();
-
-    // TODO BA-FS26 this logic isn't needed anymore when kstd::vector available, just use push_back
-    auto const slot = std::ranges::find_if(m_device_nodes, [](auto const & entry) { return !entry.has_value(); });
-    if (slot == m_device_nodes.end())
-    {
-      kapi::system::panic("[FILESYSTEM] No free slot available for device nodes.");
-    }
-
-    slot->emplace(device_node_entry{device_name, inode{device}});
+    m_device_nodes.push_back(device_node_entry{device->name(), kstd::make_shared<inode>(device)});
   }
 
   auto vfs::resolve_path(std::string_view path) -> std::optional<custody>
@@ -128,7 +111,7 @@ namespace filesystem
 
       if (entry != m_device_nodes.end())
       {
-        return custody{nullptr, &entry->value().node};
+        return custody{static_cast<kstd::shared_ptr<custody>>(nullptr), entry->value().node};
       }
 
       return std::nullopt;