From 3ace886a9e9f044cd48de51f0a15aceb02bfa9b2 Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Tue, 17 Mar 2026 19:36:20 +0100
Subject: Clean up project folder structure

---
 kernel/src/filesystem/vfs.cpp | 123 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 kernel/src/filesystem/vfs.cpp

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
new file mode 100644
index 0000000..8d2ed0a
--- /dev/null
+++ b/kernel/src/filesystem/vfs.cpp
@@ -0,0 +1,123 @@
+#include "kernel/filesystem/vfs.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/devices/storage/storage_management.hpp"
+#include "kernel/filesystem/custody.hpp"
+#include "kernel/devices/device.hpp"
+#include "kernel/filesystem/device_file.hpp"
+#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+#include "kernel/filesystem/inode.hpp"
+#include "kernel/filesystem/inode_file.hpp"
+#include "kernel/filesystem/mount.hpp"
+#include "kernel/filesystem/open_file_description.hpp"
+
+#include <kstd/cstring>
+#include <kstd/memory>
+
+#include <algorithm>
+#include <optional>
+#include <string_view>
+
+namespace filesystem
+{
+  namespace
+  {
+    constinit auto static active_vfs = std::optional<vfs>{};
+  }  // namespace
+
+  auto vfs::init() -> void
+  {
+    if (active_vfs)
+    {
+      kapi::system::panic("[FILESYSTEM] vfs has already been initialized.");
+    }
+
+    active_vfs.emplace(vfs{});
+
+    auto storage_mgmt = devices::storage::storage_management::get();
+    if (auto boot_device = storage_mgmt.determine_boot_device())
+    {
+      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{"/", 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); });
+      });
+    }
+    else
+    {
+      // TODO BA-FS26 ?? what when no boot_device == no modules loaded??
+    }
+  }
+
+  auto vfs::get() -> vfs &
+  {
+    if (!active_vfs)
+    {
+      kapi::system::panic("[FILESYSTEM] vfs has not been initialized.");
+    }
+
+    return *active_vfs;
+  }
+
+  auto vfs::open(std::string_view path) -> std::optional<open_file_description>
+  {
+    if (auto custody = resolve_path(path))
+    {
+      auto node = custody->get_inode();
+      if (node->is_device())
+      {
+        auto current_device_file = kstd::make_shared<device_file>(node->backing_device());
+        current_device_file->open();
+        return open_file_description{current_device_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(kstd::shared_ptr<devices::device> const & device) -> void
+  {
+    if (!device)
+    {
+      kapi::system::panic("[FILESYSTEM] make_device_node called with null 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>
+  {
+    // TODO BA-FS26 implement real path resolution with mounts and directories etc.
+    // For now, just support device nodes at /dev/<device_name>.
+
+    constexpr auto device_prefix = std::string_view{"/dev/"};
+    if (path.starts_with(device_prefix))
+    {
+      auto const device_name = path.substr(device_prefix.size());
+      auto entry = std::ranges::find_if(m_device_nodes, [&](auto const & device_entry) {
+        return device_entry.has_value() && device_entry->name == device_name;
+      });
+
+      if (entry != m_device_nodes.end())
+      {
+        return custody{nullptr, entry->value().node};
+      }
+
+      return std::nullopt;
+    }
+
+    return std::nullopt;
+  }
+
+}  // namespace filesystem
\ No newline at end of file
-- 
cgit v1.2.3


From fde097681f96e2c6f23ecd71a5c0037acb3ac79e Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Tue, 17 Mar 2026 19:47:53 +0100
Subject: Fix include order

---
 kernel/src/filesystem/vfs.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 8d2ed0a..2123fc7 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -2,9 +2,9 @@
 
 #include "kapi/system.hpp"
 
+#include "kernel/devices/device.hpp"
 #include "kernel/devices/storage/storage_management.hpp"
 #include "kernel/filesystem/custody.hpp"
-#include "kernel/devices/device.hpp"
 #include "kernel/filesystem/device_file.hpp"
 #include "kernel/filesystem/ext2/ext2_filesystem.hpp"
 #include "kernel/filesystem/inode.hpp"
-- 
cgit v1.2.3


From 8c502bc3423a6b3597ffbebb06a3fa3e17a6e4b0 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Wed, 18 Mar 2026 09:21:11 +0100
Subject: fix clang-tidy warnings

---
 kernel/src/filesystem/vfs.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 2123fc7..4e0b6bf 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -12,7 +12,6 @@
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
 
-#include <kstd/cstring>
 #include <kstd/memory>
 
 #include <algorithm>
-- 
cgit v1.2.3


From 8d3471f1d160d301f9d990455bd8c63450df1cf3 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Thu, 19 Mar 2026 21:59:31 +0100
Subject: remove inode metadata

---
 kernel/src/filesystem/vfs.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 4e0b6bf..188da6d 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -6,6 +6,7 @@
 #include "kernel/devices/storage/storage_management.hpp"
 #include "kernel/filesystem/custody.hpp"
 #include "kernel/filesystem/device_file.hpp"
+#include "kernel/filesystem/device_inode.hpp"
 #include "kernel/filesystem/ext2/ext2_filesystem.hpp"
 #include "kernel/filesystem/inode.hpp"
 #include "kernel/filesystem/inode_file.hpp"
@@ -72,7 +73,8 @@ namespace filesystem
       auto node = custody->get_inode();
       if (node->is_device())
       {
-        auto current_device_file = kstd::make_shared<device_file>(node->backing_device());
+        auto device_node = static_cast<device_inode *>(node.get());
+        auto current_device_file = kstd::make_shared<device_file>(device_node->backing_device());
         current_device_file->open();
         return open_file_description{current_device_file};
       }
@@ -92,7 +94,7 @@ namespace filesystem
       kapi::system::panic("[FILESYSTEM] make_device_node called with null device.");
     }
 
-    m_device_nodes.push_back(device_node_entry{device->name(), kstd::make_shared<inode>(device)});
+    m_device_nodes.push_back(device_node_entry{device->name(), kstd::make_shared<device_inode>(device)});
   }
 
   auto vfs::resolve_path(std::string_view path) -> std::optional<custody>
-- 
cgit v1.2.3


From 09e3d0cb2272e7eabd79a320c17c58124515d427 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Thu, 19 Mar 2026 22:58:31 +0100
Subject: first try to simplify the architecture (remove redundant inode_file
 and open() methods), add ext2_file placeholder struct

---
 kernel/src/filesystem/vfs.cpp | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 188da6d..4b0c7d7 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -5,11 +5,8 @@
 #include "kernel/devices/device.hpp"
 #include "kernel/devices/storage/storage_management.hpp"
 #include "kernel/filesystem/custody.hpp"
-#include "kernel/filesystem/device_file.hpp"
 #include "kernel/filesystem/device_inode.hpp"
 #include "kernel/filesystem/ext2/ext2_filesystem.hpp"
-#include "kernel/filesystem/inode.hpp"
-#include "kernel/filesystem/inode_file.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
 
@@ -71,16 +68,13 @@ namespace filesystem
     if (auto custody = resolve_path(path))
     {
       auto node = custody->get_inode();
-      if (node->is_device())
+
+      auto current_inode_file = node->open_file();
+      if (!current_inode_file)
       {
-        auto device_node = static_cast<device_inode *>(node.get());
-        auto current_device_file = kstd::make_shared<device_file>(device_node->backing_device());
-        current_device_file->open();
-        return open_file_description{current_device_file};
+        kapi::system::panic("[FILESYSTEM] inode::open_file returned null file.");
       }
 
-      auto current_inode_file = kstd::make_shared<inode_file>(node);
-      current_inode_file->open();
       return open_file_description{current_inode_file};
     }
 
-- 
cgit v1.2.3


From 91feb8a2a70af1915c8cfa4ee7d95b6e276f5c02 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 20 Mar 2026 21:51:51 +0100
Subject: small refactoring

---
 kernel/src/filesystem/vfs.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 4b0c7d7..1bc9ae6 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -69,13 +69,12 @@ namespace filesystem
     {
       auto node = custody->get_inode();
 
-      auto current_inode_file = node->open_file();
-      if (!current_inode_file)
+      if (auto current_inode_file = node->open_file();)
       {
-        kapi::system::panic("[FILESYSTEM] inode::open_file returned null file.");
+        return open_file_description{current_inode_file};
       }
 
-      return open_file_description{current_inode_file};
+      kapi::system::panic("[FILESYSTEM] inode::open_file returned null file.");
     }
 
     return std::nullopt;
-- 
cgit v1.2.3


From a396b71827a24f9d6c8010fd85b9afd9d86b6e2a Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 20 Mar 2026 22:13:36 +0100
Subject: implement first draft of a do_mount function

---
 kernel/src/filesystem/vfs.cpp | 49 +++++++++++++++++++++++++++++++++++++++----
 1 file changed, 45 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 1bc9ae6..febb844 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -36,13 +36,12 @@ namespace filesystem
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       active_vfs->m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
-      if (active_vfs->m_root_fs->mount(boot_device) != 0)
+      if (active_vfs->do_mount("/", active_vfs->m_root_fs) != 0)
       {
         kapi::system::panic("[FILESYSTEM] Failed to mount root filesystem.");
       }
 
-      active_vfs->m_root_mount = mount{"/", active_vfs->m_root_fs};
-
+      // TODO BA-FS26 use do_mount when tempdevfs is implemented -> just call /dev/ with all devices in devtempfs
       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); });
       });
@@ -69,8 +68,9 @@ namespace filesystem
     {
       auto node = custody->get_inode();
 
-      if (auto current_inode_file = node->open_file();)
+      if (auto current_inode_file = node->open_file())
       {
+        // TODO BA-FS26 return shared_ptr?
         return open_file_description{current_inode_file};
       }
 
@@ -80,6 +80,45 @@ namespace filesystem
     return std::nullopt;
   }
 
+  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> int
+  {
+    if (!filesystem)
+    {
+      return -1;  // TODO BA-FS26 panic or errorcode?
+    }
+
+    if (path.empty() || path.front() != '/')
+    {
+      return -1;  // TODO BA-FS26 panic or errorcode?
+    }
+
+    // TODO BA-FS26 better path validation
+    if ((path.size() > 1 && path.back() == '/') || path.find("//") != std::string_view::npos)
+    {
+      return -1;  // TODO BA-FS26 panic or errorcode?
+    }
+
+    if (path == "/")
+    {
+      m_root_fs = filesystem;
+      m_root_mount = mount{"/", filesystem};
+      return 0;
+    }
+
+    auto existing_mount =
+        std::ranges::find_if(m_mounts, [&](auto const & existing) { return existing.path() == path; });
+    if (existing_mount != m_mounts.end())
+    {
+      *existing_mount = mount{path, filesystem};
+    }
+    else
+    {
+      m_mounts.push_back(mount{path, filesystem});
+    }
+
+    return 0;
+  }
+
   auto vfs::make_device_node(kstd::shared_ptr<devices::device> const & device) -> void
   {
     if (!device)
@@ -94,6 +133,8 @@ namespace filesystem
   {
     // TODO BA-FS26 implement real path resolution with mounts and directories etc.
     // For now, just support device nodes at /dev/<device_name>.
+    // TODO BA-FS26 better path validation
+    // TODO BA-FS26 implement a path parser (maybe in libs?) and use it here and in do_mount
 
     constexpr auto device_prefix = std::string_view{"/dev/"};
     if (path.starts_with(device_prefix))
-- 
cgit v1.2.3


From be44d4b778bb7c3a947af4cae610ecc3b8851672 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 20 Mar 2026 22:27:26 +0100
Subject: use kstd::shared_ptr instead of std::optional for
 open_file_descriptions

---
 kernel/src/filesystem/vfs.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index febb844..a3e554e 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -7,6 +7,7 @@
 #include "kernel/filesystem/custody.hpp"
 #include "kernel/filesystem/device_inode.hpp"
 #include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+#include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
 
@@ -62,7 +63,7 @@ namespace filesystem
     return *active_vfs;
   }
 
-  auto vfs::open(std::string_view path) -> std::optional<open_file_description>
+  auto vfs::open(std::string_view path) -> kstd::shared_ptr<open_file_description>
   {
     if (auto custody = resolve_path(path))
     {
@@ -70,14 +71,13 @@ namespace filesystem
 
       if (auto current_inode_file = node->open_file())
       {
-        // TODO BA-FS26 return shared_ptr?
-        return open_file_description{current_inode_file};
+        return kstd::make_shared<open_file_description>(current_inode_file);
       }
 
       kapi::system::panic("[FILESYSTEM] inode::open_file returned null file.");
     }
 
-    return std::nullopt;
+    return nullptr;
   }
 
   auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> int
-- 
cgit v1.2.3


From 90452b752688110db2edc8d5dccdf0d6e0face5f Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 20 Mar 2026 23:17:11 +0100
Subject: fix build

---
 kernel/src/filesystem/vfs.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index a3e554e..ee5fd9b 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -93,7 +93,7 @@ namespace filesystem
     }
 
     // TODO BA-FS26 better path validation
-    if ((path.size() > 1 && path.back() == '/') || path.find("//") != std::string_view::npos)
+    if ((path.size() > 1 && path.back() == '/'))
     {
       return -1;  // TODO BA-FS26 panic or errorcode?
     }
-- 
cgit v1.2.3


From ba63fbfc2bb43a6f0f05b6b49fd51fd6c89a0861 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 21 Mar 2026 00:28:17 +0100
Subject: refactor file and inode architecture again

---
 kernel/src/filesystem/vfs.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index ee5fd9b..5330b82 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -34,6 +34,7 @@ namespace filesystem
     active_vfs.emplace(vfs{});
 
     auto storage_mgmt = devices::storage::storage_management::get();
+    // TODO BA-FS26 fix mounting boot_device
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       active_vfs->m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
@@ -69,9 +70,9 @@ namespace filesystem
     {
       auto node = custody->get_inode();
 
-      if (auto current_inode_file = node->open_file())
+      if (auto opened_file = node->open_file(node))
       {
-        return kstd::make_shared<open_file_description>(current_inode_file);
+        return kstd::make_shared<open_file_description>(opened_file);
       }
 
       kapi::system::panic("[FILESYSTEM] inode::open_file returned null file.");
-- 
cgit v1.2.3


From ffb2accb09a013d8da16acd824c846bc1acfd8e4 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 21 Mar 2026 10:52:46 +0100
Subject: use enable_shared_from_this instead of self invocation method

---
 kernel/src/filesystem/vfs.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 5330b82..2316de0 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -70,7 +70,7 @@ namespace filesystem
     {
       auto node = custody->get_inode();
 
-      if (auto opened_file = node->open_file(node))
+      if (auto opened_file = node->open_file())
       {
         return kstd::make_shared<open_file_description>(opened_file);
       }
-- 
cgit v1.2.3


From 6c172389b562a08a6540574d6fbdf6a5bdce37b8 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 21 Mar 2026 16:22:23 +0100
Subject: simplify architecture again

---
 kernel/src/filesystem/vfs.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 2316de0..86991ea 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -68,11 +68,9 @@ namespace filesystem
   {
     if (auto custody = resolve_path(path))
     {
-      auto node = custody->get_inode();
-
-      if (auto opened_file = node->open_file())
+      if (auto node = custody->get_inode())
       {
-        return kstd::make_shared<open_file_description>(opened_file);
+        return kstd::make_shared<open_file_description>(node);
       }
 
       kapi::system::panic("[FILESYSTEM] inode::open_file returned null file.");
-- 
cgit v1.2.3


From 9d23a9fb6ae774bf3b1345d0b7adcb88f9627dc0 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 21 Mar 2026 16:35:01 +0100
Subject: refactoring, node cannot be null

---
 kernel/src/filesystem/vfs.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 86991ea..c448618 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -68,12 +68,7 @@ namespace filesystem
   {
     if (auto custody = resolve_path(path))
     {
-      if (auto node = custody->get_inode())
-      {
-        return kstd::make_shared<open_file_description>(node);
-      }
-
-      kapi::system::panic("[FILESYSTEM] inode::open_file returned null file.");
+      return kstd::make_shared<open_file_description>(custody->get_inode());
     }
 
     return nullptr;
-- 
cgit v1.2.3


From ac3510bb9f696869f059ecd4ece2c6970fa63b6c Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 21 Mar 2026 23:57:49 +0100
Subject: implement device names with kstd::string

---
 kernel/src/filesystem/vfs.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index c448618..1bd6fb5 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -120,7 +120,7 @@ namespace filesystem
       kapi::system::panic("[FILESYSTEM] make_device_node called with null device.");
     }
 
-    m_device_nodes.push_back(device_node_entry{device->name(), kstd::make_shared<device_inode>(device)});
+    m_device_nodes.push_back(device_node_entry{device->name().view(), kstd::make_shared<device_inode>(device)});
   }
 
   auto vfs::resolve_path(std::string_view path) -> std::optional<custody>
-- 
cgit v1.2.3


From f90cbdaa91b1b7a4752db3f159ce2524696cff9f Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 23 Mar 2026 09:03:27 +0100
Subject: Rename custody to dentry and add children

---
 kernel/src/filesystem/vfs.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 1bd6fb5..a111f23 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -4,7 +4,7 @@
 
 #include "kernel/devices/device.hpp"
 #include "kernel/devices/storage/storage_management.hpp"
-#include "kernel/filesystem/custody.hpp"
+#include "kernel/filesystem/dentry.hpp"
 #include "kernel/filesystem/device_inode.hpp"
 #include "kernel/filesystem/ext2/ext2_filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
@@ -66,9 +66,9 @@ namespace filesystem
 
   auto vfs::open(std::string_view path) -> kstd::shared_ptr<open_file_description>
   {
-    if (auto custody = resolve_path(path))
+    if (auto dentry = resolve_path(path))
     {
-      return kstd::make_shared<open_file_description>(custody->get_inode());
+      return kstd::make_shared<open_file_description>(dentry->get_inode());
     }
 
     return nullptr;
@@ -100,14 +100,14 @@ namespace filesystem
     }
 
     auto existing_mount =
-        std::ranges::find_if(m_mounts, [&](auto const & existing) { return existing.path() == path; });
-    if (existing_mount != m_mounts.end())
+        std::ranges::find_if(m_mount_table, [&](auto const & existing) { return existing.path() == path; });
+    if (existing_mount != m_mount_table.end())
     {
       *existing_mount = mount{path, filesystem};
     }
     else
     {
-      m_mounts.push_back(mount{path, filesystem});
+      m_mount_table.push_back(mount{path, filesystem});
     }
 
     return 0;
@@ -123,7 +123,7 @@ namespace filesystem
     m_device_nodes.push_back(device_node_entry{device->name().view(), kstd::make_shared<device_inode>(device)});
   }
 
-  auto vfs::resolve_path(std::string_view path) -> std::optional<custody>
+  auto vfs::resolve_path(std::string_view path) -> std::optional<dentry>
   {
     // TODO BA-FS26 implement real path resolution with mounts and directories etc.
     // For now, just support device nodes at /dev/<device_name>.
@@ -140,7 +140,7 @@ namespace filesystem
 
       if (entry != m_device_nodes.end())
       {
-        return custody{nullptr, entry->value().node};
+        return dentry{nullptr, entry->value().node};
       }
 
       return std::nullopt;
-- 
cgit v1.2.3


From d70e2df0885a844d47b6498bf2c710fb9730b364 Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 23 Mar 2026 09:49:10 +0100
Subject: Add dentry structure

---
 kernel/src/filesystem/vfs.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index a111f23..2c4a4d5 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -38,10 +38,11 @@ namespace filesystem
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       active_vfs->m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
-      if (active_vfs->do_mount("/", active_vfs->m_root_fs) != 0)
-      {
-        kapi::system::panic("[FILESYSTEM] Failed to mount root filesystem.");
-      }
+      active_vfs->m_root_dentry = kstd::make_shared<dentry>(nullptr, active_vfs->m_root_fs->root_inode());
+      // if (active_vfs->do_mount("/", active_vfs->m_root_fs) != 0)
+      // {
+      //   kapi::system::panic("[FILESYSTEM] Failed to mount root filesystem.");
+      // }
 
       // TODO BA-FS26 use do_mount when tempdevfs is implemented -> just call /dev/ with all devices in devtempfs
       std::ranges::for_each(storage_mgmt.all_controllers(), [&](auto controller) {
@@ -92,12 +93,12 @@ namespace filesystem
       return -1;  // TODO BA-FS26 panic or errorcode?
     }
 
-    if (path == "/")
-    {
-      m_root_fs = filesystem;
-      m_root_mount = mount{"/", filesystem};
-      return 0;
-    }
+    // if (path == "/")
+    // {
+    //   m_root_fs = filesystem;
+    //   m_root_mount = mount{"/", filesystem};
+    //   return 0;
+    // }
 
     auto existing_mount =
         std::ranges::find_if(m_mount_table, [&](auto const & existing) { return existing.path() == path; });
-- 
cgit v1.2.3


From 7173e5ba354dccc4b5d5fea119b946f28bc5b08f Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 23 Mar 2026 20:22:43 +0100
Subject: Refactor move init logic into member function

---
 kernel/src/filesystem/vfs.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 2c4a4d5..ece3080 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -32,21 +32,28 @@ namespace filesystem
     }
 
     active_vfs.emplace(vfs{});
+    active_vfs->init_internal();
+  }
 
+  auto vfs::init_internal() -> void
+  {
     auto storage_mgmt = devices::storage::storage_management::get();
     // TODO BA-FS26 fix mounting boot_device
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
-      active_vfs->m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
-      active_vfs->m_root_dentry = kstd::make_shared<dentry>(nullptr, active_vfs->m_root_fs->root_inode());
-      // if (active_vfs->do_mount("/", active_vfs->m_root_fs) != 0)
+      m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
+
+      m_root_fs->mount(boot_device);
+
+      m_root_dentry = kstd::make_shared<dentry>(nullptr, m_root_fs->root_inode());
+      // if (do_mount("/", m_root_fs) != 0)
       // {
       //   kapi::system::panic("[FILESYSTEM] Failed to mount root filesystem.");
       // }
 
       // TODO BA-FS26 use do_mount when tempdevfs is implemented -> just call /dev/ with all devices in devtempfs
       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); });
+        std::ranges::for_each(controller->all_devices(), [&](auto device) { make_device_node(device); });
       });
     }
     else
-- 
cgit v1.2.3


From fbb4eefce7bf825b0406f6fa63de318153a3b95a Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 23 Mar 2026 21:41:37 +0100
Subject: Implement resolve_path

---
 kernel/src/filesystem/vfs.cpp | 46 ++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 41 insertions(+), 5 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index ece3080..0e8a76d 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -15,6 +15,7 @@
 
 #include <algorithm>
 #include <optional>
+#include <ranges>
 #include <string_view>
 
 namespace filesystem
@@ -42,7 +43,6 @@ namespace filesystem
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
-
       m_root_fs->mount(boot_device);
 
       m_root_dentry = kstd::make_shared<dentry>(nullptr, m_root_fs->root_inode());
@@ -131,7 +131,7 @@ namespace filesystem
     m_device_nodes.push_back(device_node_entry{device->name().view(), kstd::make_shared<device_inode>(device)});
   }
 
-  auto vfs::resolve_path(std::string_view path) -> std::optional<dentry>
+  auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
   {
     // TODO BA-FS26 implement real path resolution with mounts and directories etc.
     // For now, just support device nodes at /dev/<device_name>.
@@ -148,13 +148,49 @@ namespace filesystem
 
       if (entry != m_device_nodes.end())
       {
-        return dentry{nullptr, entry->value().node};
+        return kstd::make_shared<dentry>(nullptr, entry->value().node);
       }
 
-      return std::nullopt;
+      return nullptr;
     }
+    else if (!path.empty() && path.front() == '/')
+    {
+      auto path_parts =
+          std::views::split(path, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
+      auto parent = m_root_dentry;
 
-    return std::nullopt;
+      for (auto const & part : path_parts)
+      {
+        if (auto child = parent->find_child(std::string_view{part}))
+        {
+          parent = child;
+        }
+        else if (auto found_inode = m_root_fs->lookup(parent->get_inode(), std::string_view{part}))
+        {
+          auto next_dentry = kstd::make_shared<dentry>(parent, found_inode, std::string_view{part});
+          parent->add_child(next_dentry);
+          parent = next_dentry;
+        }
+        else
+        {
+          return nullptr;
+        }
+      }
+      // | std::views::transform([this](auto const & part) {
+      //     // TODO BA-FS26 implement real path resolution with mounts and directories etc.
+      //     // For now, just return null for any non-device-node path.
+      //     return std::optional<kstd::shared_ptr<dentry>>{};
+      //   })
+      // | std::views::filter([](auto const & opt) { return opt.has_value(); })
+      // | std::views::transform([](auto const & opt) { return opt.value(); })
+      // | std::ranges::find_if(m_mount_table, [&](auto const & mount) {
+      //     // TODO BA-FS26 implement real path resolution with mounts and directories etc.
+      //     // For now, just check if the first path component matches a mount point.
+      //     return part == mount.path();
+      //   });
+    }
+
+    return nullptr;
   }
 
 }  // namespace filesystem
\ No newline at end of file
-- 
cgit v1.2.3


From a2ac8770937a28d0d4c674e25c9b3c77802a5c9e Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Tue, 24 Mar 2026 17:22:55 +0100
Subject: Refactor mounting of new filesystems and path resolving in vfs

---
 kernel/src/filesystem/vfs.cpp | 53 ++++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 23 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 0e8a76d..c77736a 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -82,9 +82,9 @@ namespace filesystem
     return nullptr;
   }
 
-  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> int
+  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & new_filesystem) -> int
   {
-    if (!filesystem)
+    if (!new_filesystem)
     {
       return -1;  // TODO BA-FS26 panic or errorcode?
     }
@@ -100,24 +100,21 @@ namespace filesystem
       return -1;  // TODO BA-FS26 panic or errorcode?
     }
 
-    // if (path == "/")
-    // {
-    //   m_root_fs = filesystem;
-    //   m_root_mount = mount{"/", filesystem};
-    //   return 0;
-    // }
+    auto mount_dentry = resolve_path(path);
 
-    auto existing_mount =
-        std::ranges::find_if(m_mount_table, [&](auto const & existing) { return existing.path() == path; });
-    if (existing_mount != m_mount_table.end())
+    if (!mount_dentry)
     {
-      *existing_mount = mount{path, filesystem};
-    }
-    else
-    {
-      m_mount_table.push_back(mount{path, filesystem});
+      return -1;  // mount point path doesn't exist
     }
 
+    // TODO BA-FS26 check if mount point is already mounted and handle it (unmount old fs, fail, etc.)
+
+    mount_dentry->set_flag(dentry::dentry_flags::dcache_mounted);
+    m_mount_table.add_mount(kstd::make_shared<mount>(mount_dentry, new_filesystem));
+
+    new_filesystem->set_root_dentry(
+        kstd::make_shared<dentry>(mount_dentry->get_parent(), new_filesystem->root_inode()));
+
     return 0;
   }
 
@@ -157,19 +154,29 @@ namespace filesystem
     {
       auto path_parts =
           std::views::split(path, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
-      auto parent = m_root_dentry;
+      auto current_parent = m_root_dentry;
+      auto current_fs = m_root_fs;
 
       for (auto const & part : path_parts)
       {
-        if (auto child = parent->find_child(std::string_view{part}))
+        if (auto child = current_parent->find_child(std::string_view{part}))
         {
-          parent = child;
+          if (child->has_flag(dentry::dentry_flags::dcache_mounted))  // found dentry is a mounted fs
+          {
+            auto found_mount = m_mount_table.find_mount_by_dentry(child);
+            current_fs = found_mount->get_filesystem();
+            current_parent = current_fs->root_dentry();
+          }
+          else
+          {  // found dentry is NOT a mounted fs -> continue path resolution in current fs
+            current_parent = child;
+          }
         }
-        else if (auto found_inode = m_root_fs->lookup(parent->get_inode(), std::string_view{part}))
+        else if (auto found_inode = m_root_fs->lookup(current_parent->get_inode(), std::string_view{part}))
         {
-          auto next_dentry = kstd::make_shared<dentry>(parent, found_inode, std::string_view{part});
-          parent->add_child(next_dentry);
-          parent = next_dentry;
+          auto next_dentry = kstd::make_shared<dentry>(current_parent, found_inode, std::string_view{part});
+          current_parent->add_child(next_dentry);
+          current_parent = next_dentry;
         }
         else
         {
-- 
cgit v1.2.3


From 7351349f296f100f10db62b5a834a971fbe51473 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 24 Mar 2026 18:52:41 +0100
Subject: small refactoring

---
 kernel/src/filesystem/vfs.cpp | 36 ++++++++++--------------------------
 1 file changed, 10 insertions(+), 26 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index c77736a..78dec77 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -39,7 +39,6 @@ namespace filesystem
   auto vfs::init_internal() -> void
   {
     auto storage_mgmt = devices::storage::storage_management::get();
-    // TODO BA-FS26 fix mounting boot_device
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
@@ -82,9 +81,9 @@ namespace filesystem
     return nullptr;
   }
 
-  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & new_filesystem) -> int
+  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> int
   {
-    if (!new_filesystem)
+    if (!filesystem)
     {
       return -1;  // TODO BA-FS26 panic or errorcode?
     }
@@ -100,22 +99,19 @@ namespace filesystem
       return -1;  // TODO BA-FS26 panic or errorcode?
     }
 
-    auto mount_dentry = resolve_path(path);
-
-    if (!mount_dentry)
+    if (auto mount_dentry = resolve_path(path))
     {
-      return -1;  // mount point path doesn't exist
-    }
+      // TODO BA-FS26 check if mount point is already mounted and handle it (unmount old fs, fail, etc.)
 
-    // TODO BA-FS26 check if mount point is already mounted and handle it (unmount old fs, fail, etc.)
+      mount_dentry->set_flag(dentry::dentry_flags::dcache_mounted);
+      m_mount_table.add_mount(kstd::make_shared<mount>(mount_dentry, filesystem));
 
-    mount_dentry->set_flag(dentry::dentry_flags::dcache_mounted);
-    m_mount_table.add_mount(kstd::make_shared<mount>(mount_dentry, new_filesystem));
+      filesystem->set_root_dentry(kstd::make_shared<dentry>(mount_dentry->get_parent(), filesystem->root_inode()));
 
-    new_filesystem->set_root_dentry(
-        kstd::make_shared<dentry>(mount_dentry->get_parent(), new_filesystem->root_inode()));
+      return 0;
+    }
 
-    return 0;
+    return -1;
   }
 
   auto vfs::make_device_node(kstd::shared_ptr<devices::device> const & device) -> void
@@ -183,18 +179,6 @@ namespace filesystem
           return nullptr;
         }
       }
-      // | std::views::transform([this](auto const & part) {
-      //     // TODO BA-FS26 implement real path resolution with mounts and directories etc.
-      //     // For now, just return null for any non-device-node path.
-      //     return std::optional<kstd::shared_ptr<dentry>>{};
-      //   })
-      // | std::views::filter([](auto const & opt) { return opt.has_value(); })
-      // | std::views::transform([](auto const & opt) { return opt.value(); })
-      // | std::ranges::find_if(m_mount_table, [&](auto const & mount) {
-      //     // TODO BA-FS26 implement real path resolution with mounts and directories etc.
-      //     // For now, just check if the first path component matches a mount point.
-      //     return part == mount.path();
-      //   });
     }
 
     return nullptr;
-- 
cgit v1.2.3


From 76de81de1e12694bf6bec1edd3e3409092a92d09 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 24 Mar 2026 20:41:32 +0100
Subject: refactoring, add root_mount into the root_table

---
 kernel/src/filesystem/vfs.cpp | 53 +++++++++++++++++++++++++------------------
 1 file changed, 31 insertions(+), 22 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 78dec77..c8e5bc5 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -41,14 +41,13 @@ namespace filesystem
     auto storage_mgmt = devices::storage::storage_management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
-      m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
-      m_root_fs->mount(boot_device);
+      auto root_fs = kstd::make_shared<ext2::ext2_filesystem>();
+      root_fs->mount(boot_device);
 
-      m_root_dentry = kstd::make_shared<dentry>(nullptr, m_root_fs->root_inode());
-      // if (do_mount("/", m_root_fs) != 0)
-      // {
-      //   kapi::system::panic("[FILESYSTEM] Failed to mount root filesystem.");
-      // }
+      auto root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
+      root_fs->set_root_dentry(root_dentry);
+
+      m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs));
 
       // TODO BA-FS26 use do_mount when tempdevfs is implemented -> just call /dev/ with all devices in devtempfs
       std::ranges::for_each(storage_mgmt.all_controllers(), [&](auto controller) {
@@ -148,37 +147,47 @@ namespace filesystem
     }
     else if (!path.empty() && path.front() == '/')
     {
+      auto root_mount = m_mount_table.get_root_mount();
+      if (!root_mount)
+      {
+        kapi::system::panic("[FILESYSTEM] no root mount found.");
+      }
+
+      auto current_dentry = root_mount->get_dentry();
+      auto current_fs = root_mount->get_filesystem();
+
       auto path_parts =
           std::views::split(path, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
-      auto current_parent = m_root_dentry;
-      auto current_fs = m_root_fs;
-
       for (auto const & part : path_parts)
       {
-        if (auto child = current_parent->find_child(std::string_view{part}))
+        auto next_dentry = current_dentry->find_child(std::string_view{part});
+
+        if (!next_dentry)
         {
-          if (child->has_flag(dentry::dentry_flags::dcache_mounted))  // found dentry is a mounted fs
+          if (auto found_inode = current_fs->lookup(current_dentry->get_inode(), std::string_view{part}))
           {
-            auto found_mount = m_mount_table.find_mount_by_dentry(child);
-            current_fs = found_mount->get_filesystem();
-            current_parent = current_fs->root_dentry();
+            next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, std::string_view{part});
+            current_dentry->add_child(next_dentry);
           }
           else
-          {  // found dentry is NOT a mounted fs -> continue path resolution in current fs
-            current_parent = child;
+          {
+            return nullptr;
           }
         }
-        else if (auto found_inode = m_root_fs->lookup(current_parent->get_inode(), std::string_view{part}))
+
+        if (next_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
         {
-          auto next_dentry = kstd::make_shared<dentry>(current_parent, found_inode, std::string_view{part});
-          current_parent->add_child(next_dentry);
-          current_parent = next_dentry;
+          auto found_mount = m_mount_table.find_mount_by_dentry(next_dentry);
+          current_fs = found_mount->get_filesystem();
+          current_dentry = current_fs->root_dentry();
         }
         else
         {
-          return nullptr;
+          current_dentry = next_dentry;
         }
       }
+
+      return current_dentry;
     }
 
     return nullptr;
-- 
cgit v1.2.3


From 84d4476650b31dbfc52becf2ff65ddce9d31c9ec Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 24 Mar 2026 23:54:28 +0100
Subject: implement a rootfs to handle / mounts correctly

---
 kernel/src/filesystem/vfs.cpp | 43 +++++++++++++++++++++++++++++--------------
 1 file changed, 29 insertions(+), 14 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index c8e5bc5..1c4dd8b 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -10,6 +10,7 @@
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
+#include "kernel/filesystem/rootfs/rootfs_filesystem.hpp"
 
 #include <kstd/memory>
 
@@ -38,16 +39,20 @@ namespace filesystem
 
   auto vfs::init_internal() -> void
   {
+    auto virtual_fs = kstd::make_shared<rootfs::rootfs_filesystem>();
+    virtual_fs->mount(nullptr);
+
+    auto virtual_root_dentry = kstd::make_shared<dentry>(nullptr, virtual_fs->root_inode(), "/");
+    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, virtual_root_dentry, virtual_fs));
+
     auto storage_mgmt = devices::storage::storage_management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
-      auto root_fs = kstd::make_shared<ext2::ext2_filesystem>();
-      root_fs->mount(boot_device);
+      // TODO BA-FS26 detect fs type from boot device and load corresponding fs, for now just assume ext2
+      auto boot_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
+      boot_root_fs->mount(boot_device);
 
-      auto root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
-      root_fs->set_root_dentry(root_dentry);
-
-      m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs));
+      do_mount("/", boot_root_fs);
 
       // TODO BA-FS26 use do_mount when tempdevfs is implemented -> just call /dev/ with all devices in devtempfs
       std::ranges::for_each(storage_mgmt.all_controllers(), [&](auto controller) {
@@ -102,10 +107,10 @@ namespace filesystem
     {
       // TODO BA-FS26 check if mount point is already mounted and handle it (unmount old fs, fail, etc.)
 
+      auto new_fs_root = kstd::make_shared<dentry>(mount_dentry, filesystem->root_inode());
+      auto new_mount = kstd::make_shared<mount>(mount_dentry, new_fs_root, filesystem);
+      m_mount_table.add_mount(new_mount);
       mount_dentry->set_flag(dentry::dentry_flags::dcache_mounted);
-      m_mount_table.add_mount(kstd::make_shared<mount>(mount_dentry, filesystem));
-
-      filesystem->set_root_dentry(kstd::make_shared<dentry>(mount_dentry->get_parent(), filesystem->root_inode()));
 
       return 0;
     }
@@ -153,20 +158,30 @@ namespace filesystem
         kapi::system::panic("[FILESYSTEM] no root mount found.");
       }
 
-      auto current_dentry = root_mount->get_dentry();
+      auto current_dentry = root_mount->root_dentry();
       auto current_fs = root_mount->get_filesystem();
 
+      while (current_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
+      {
+        auto mnt = m_mount_table.find_mount_by_dentry(current_dentry);
+        if (!mnt)
+          kapi::system::panic("[FILESYSTEM] dcache_mounted set but no covering mount found.");
+        current_dentry = mnt->root_dentry();
+        current_fs = mnt->get_filesystem();
+      }
+
       auto path_parts =
           std::views::split(path, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
       for (auto const & part : path_parts)
       {
-        auto next_dentry = current_dentry->find_child(std::string_view{part});
+        std::string_view part_view{part};
+        auto next_dentry = current_dentry->find_child(part_view);
 
         if (!next_dentry)
         {
-          if (auto found_inode = current_fs->lookup(current_dentry->get_inode(), std::string_view{part}))
+          if (auto found_inode = current_fs->lookup(current_dentry->get_inode(), part_view))
           {
-            next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, std::string_view{part});
+            next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part_view);
             current_dentry->add_child(next_dentry);
           }
           else
@@ -179,7 +194,7 @@ namespace filesystem
         {
           auto found_mount = m_mount_table.find_mount_by_dentry(next_dentry);
           current_fs = found_mount->get_filesystem();
-          current_dentry = current_fs->root_dentry();
+          current_dentry = found_mount->root_dentry();
         }
         else
         {
-- 
cgit v1.2.3


From 74351bbcd440189bafa79c806dd3ae8255f42c11 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Wed, 25 Mar 2026 07:47:24 +0100
Subject: currently do not support stacked mounts

---
 kernel/src/filesystem/vfs.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 1c4dd8b..483bae5 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -161,7 +161,8 @@ namespace filesystem
       auto current_dentry = root_mount->root_dentry();
       auto current_fs = root_mount->get_filesystem();
 
-      while (current_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
+      // TODO BA-FS26 use while to allow stacked mounts?
+      if (current_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
       {
         auto mnt = m_mount_table.find_mount_by_dentry(current_dentry);
         if (!mnt)
@@ -190,6 +191,7 @@ namespace filesystem
           }
         }
 
+        // TODO BA-FS26 use while to allow stacked mounts?
         if (next_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
         {
           auto found_mount = m_mount_table.find_mount_by_dentry(next_dentry);
-- 
cgit v1.2.3


From 31ac3e6ffff00b7ac3b3dbb3db38c44409251b34 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Thu, 26 Mar 2026 20:09:37 +0100
Subject: first draft of an devfs implementation

---
 kernel/src/filesystem/vfs.cpp | 50 ++++++++++++-------------------------------
 1 file changed, 14 insertions(+), 36 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 483bae5..368d994 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -2,10 +2,9 @@
 
 #include "kapi/system.hpp"
 
-#include "kernel/devices/device.hpp"
 #include "kernel/devices/storage/storage_management.hpp"
 #include "kernel/filesystem/dentry.hpp"
-#include "kernel/filesystem/device_inode.hpp"
+#include "kernel/filesystem/devfs/devfs_filesystem.hpp"
 #include "kernel/filesystem/ext2/ext2_filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
@@ -14,7 +13,6 @@
 
 #include <kstd/memory>
 
-#include <algorithm>
 #include <optional>
 #include <ranges>
 #include <string_view>
@@ -52,12 +50,18 @@ namespace filesystem
       auto boot_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
       boot_root_fs->mount(boot_device);
 
-      do_mount("/", boot_root_fs);
+      if (do_mount("/", boot_root_fs) != 0)
+      {
+        kapi::system::panic("[FILESYSTEM] failed to mount root filesystem.");
+      }
+
+      auto device_fs = kstd::make_shared<devfs::devfs_filesystem>();
+      device_fs->mount(nullptr);
 
-      // TODO BA-FS26 use do_mount when tempdevfs is implemented -> just call /dev/ with all devices in devtempfs
-      std::ranges::for_each(storage_mgmt.all_controllers(), [&](auto controller) {
-        std::ranges::for_each(controller->all_devices(), [&](auto device) { make_device_node(device); });
-      });
+      if (do_mount("/dev", device_fs) != 0)
+      {
+        kapi::system::panic("[FILESYSTEM] failed to mount devfs at /dev.");
+      }
     }
     else
     {
@@ -118,39 +122,13 @@ namespace filesystem
     return -1;
   }
 
-  auto vfs::make_device_node(kstd::shared_ptr<devices::device> const & device) -> void
-  {
-    if (!device)
-    {
-      kapi::system::panic("[FILESYSTEM] make_device_node called with null device.");
-    }
-
-    m_device_nodes.push_back(device_node_entry{device->name().view(), kstd::make_shared<device_inode>(device)});
-  }
-
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
   {
-    // TODO BA-FS26 implement real path resolution with mounts and directories etc.
-    // For now, just support device nodes at /dev/<device_name>.
+    // TODO BA-FS26 implement full path resolution semantics.
     // TODO BA-FS26 better path validation
     // TODO BA-FS26 implement a path parser (maybe in libs?) and use it here and in do_mount
 
-    constexpr auto device_prefix = std::string_view{"/dev/"};
-    if (path.starts_with(device_prefix))
-    {
-      auto const device_name = path.substr(device_prefix.size());
-      auto entry = std::ranges::find_if(m_device_nodes, [&](auto const & device_entry) {
-        return device_entry.has_value() && device_entry->name == device_name;
-      });
-
-      if (entry != m_device_nodes.end())
-      {
-        return kstd::make_shared<dentry>(nullptr, entry->value().node);
-      }
-
-      return nullptr;
-    }
-    else if (!path.empty() && path.front() == '/')
+    if (!path.empty() && path.front() == '/')
     {
       auto root_mount = m_mount_table.get_root_mount();
       if (!root_mount)
-- 
cgit v1.2.3


From c3e80174faa2db9e6674af995aaa95b59ec53fec Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Thu, 26 Mar 2026 21:15:40 +0100
Subject: fix resolve_path -> first traverse rootfs before jumping into the
 mounted root filesystem

---
 kernel/src/filesystem/vfs.cpp | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 368d994..40c97f8 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -139,16 +139,6 @@ namespace filesystem
       auto current_dentry = root_mount->root_dentry();
       auto current_fs = root_mount->get_filesystem();
 
-      // TODO BA-FS26 use while to allow stacked mounts?
-      if (current_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
-      {
-        auto mnt = m_mount_table.find_mount_by_dentry(current_dentry);
-        if (!mnt)
-          kapi::system::panic("[FILESYSTEM] dcache_mounted set but no covering mount found.");
-        current_dentry = mnt->root_dentry();
-        current_fs = mnt->get_filesystem();
-      }
-
       auto path_parts =
           std::views::split(path, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
       for (auto const & part : path_parts)
@@ -173,6 +163,8 @@ namespace filesystem
         if (next_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
         {
           auto found_mount = m_mount_table.find_mount_by_dentry(next_dentry);
+          if (!found_mount)
+            kapi::system::panic("[FILESYSTEM] dcache_mounted set but no covering mount found.");
           current_fs = found_mount->get_filesystem();
           current_dentry = found_mount->root_dentry();
         }
-- 
cgit v1.2.3


From a6f93bf8df0dbfa7d19aa1168bfc8b052e41c42f Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 28 Mar 2026 17:28:32 +0100
Subject: fix vfs mount with /dev & /a  and rootfs & devfs

---
 kernel/src/filesystem/vfs.cpp | 122 ++++++++++++++++++------------------------
 1 file changed, 51 insertions(+), 71 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 40c97f8..da7fa05 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -37,11 +37,11 @@ namespace filesystem
 
   auto vfs::init_internal() -> void
   {
-    auto virtual_fs = kstd::make_shared<rootfs::rootfs_filesystem>();
-    virtual_fs->mount(nullptr);
+    auto root_fs = kstd::make_shared<rootfs::rootfs_filesystem>();
+    root_fs->mount(nullptr);
 
-    auto virtual_root_dentry = kstd::make_shared<dentry>(nullptr, virtual_fs->root_inode(), "/");
-    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, virtual_root_dentry, virtual_fs));
+    auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode());
+    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, ""));
 
     auto storage_mgmt = devices::storage::storage_management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
@@ -49,24 +49,12 @@ namespace filesystem
       // TODO BA-FS26 detect fs type from boot device and load corresponding fs, for now just assume ext2
       auto boot_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
       boot_root_fs->mount(boot_device);
-
-      if (do_mount("/", boot_root_fs) != 0)
-      {
-        kapi::system::panic("[FILESYSTEM] failed to mount root filesystem.");
-      }
-
-      auto device_fs = kstd::make_shared<devfs::devfs_filesystem>();
-      device_fs->mount(nullptr);
-
-      if (do_mount("/dev", device_fs) != 0)
-      {
-        kapi::system::panic("[FILESYSTEM] failed to mount devfs at /dev.");
-      }
-    }
-    else
-    {
-      // TODO BA-FS26 ?? what when no boot_device == no modules loaded??
+      do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
     }
+
+    auto device_fs = kstd::make_shared<devfs::devfs_filesystem>();
+    device_fs->mount(nullptr);
+    do_mount_internal("/dev", root_fs_root_dentry, device_fs);
   }
 
   auto vfs::get() -> vfs &
@@ -107,77 +95,69 @@ namespace filesystem
       return -1;  // TODO BA-FS26 panic or errorcode?
     }
 
-    if (auto mount_dentry = resolve_path(path))
+    if (auto mount_point_dentry = resolve_path(path))
     {
-      // TODO BA-FS26 check if mount point is already mounted and handle it (unmount old fs, fail, etc.)
-
-      auto new_fs_root = kstd::make_shared<dentry>(mount_dentry, filesystem->root_inode());
-      auto new_mount = kstd::make_shared<mount>(mount_dentry, new_fs_root, filesystem);
-      m_mount_table.add_mount(new_mount);
-      mount_dentry->set_flag(dentry::dentry_flags::dcache_mounted);
-
+      do_mount_internal(path, mount_point_dentry, filesystem);
       return 0;
     }
 
     return -1;
   }
 
+  auto vfs::do_mount_internal(std::string_view path, kstd::shared_ptr<dentry> const & mount_point_dentry,
+                              kstd::shared_ptr<filesystem> const & fs) -> void
+  {
+    // TODO BA-FS26 check if mount point is already mounted and handle it (unmount old fs, fail, etc.)
+    auto new_fs_root = kstd::make_shared<dentry>(mount_point_dentry, fs->root_inode());
+    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, path);
+    m_mount_table.add_mount(new_mount);
+  }
+
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
   {
     // TODO BA-FS26 implement full path resolution semantics.
     // TODO BA-FS26 better path validation
     // TODO BA-FS26 implement a path parser (maybe in libs?) and use it here and in do_mount
 
-    if (!path.empty() && path.front() == '/')
+    if (path.empty() || path.front() != '/')
+      return nullptr;
+
+    // TODO BA-FS26 longest match in mount_table -> jump into final fs directly
+    // TODO BA-FS26 performance optimization first check mounted_flag O(1) then check mount_table O(n)
+
+    auto best_mount = m_mount_table.find_longest_prefix_mount(path);
+    if (!best_mount)
     {
-      auto root_mount = m_mount_table.get_root_mount();
-      if (!root_mount)
-      {
-        kapi::system::panic("[FILESYSTEM] no root mount found.");
-      }
+      kapi::system::panic("[FILESYSTEM] no root mount found.");
+    }
 
-      auto current_dentry = root_mount->root_dentry();
-      auto current_fs = root_mount->get_filesystem();
+    auto current_dentry = best_mount->root_dentry();
+    auto current_fs = best_mount->get_filesystem();
 
-      auto path_parts =
-          std::views::split(path, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
-      for (auto const & part : path_parts)
+    std::string_view remaining = path.substr(best_mount->get_mount_path().size());
+
+    auto path_parts =
+        std::views::split(remaining, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
+
+    for (auto const & part : path_parts)
+    {
+      std::string_view part_view{part};
+
+      auto next_dentry = current_dentry->find_child(part_view);
+      if (!next_dentry)
       {
-        std::string_view part_view{part};
-        auto next_dentry = current_dentry->find_child(part_view);
-
-        if (!next_dentry)
-        {
-          if (auto found_inode = current_fs->lookup(current_dentry->get_inode(), part_view))
-          {
-            next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part_view);
-            current_dentry->add_child(next_dentry);
-          }
-          else
-          {
-            return nullptr;
-          }
-        }
-
-        // TODO BA-FS26 use while to allow stacked mounts?
-        if (next_dentry->has_flag(dentry::dentry_flags::dcache_mounted))
-        {
-          auto found_mount = m_mount_table.find_mount_by_dentry(next_dentry);
-          if (!found_mount)
-            kapi::system::panic("[FILESYSTEM] dcache_mounted set but no covering mount found.");
-          current_fs = found_mount->get_filesystem();
-          current_dentry = found_mount->root_dentry();
-        }
-        else
-        {
-          current_dentry = next_dentry;
-        }
+        auto found_inode = current_fs->lookup(current_dentry->get_inode(), part_view);
+        if (!found_inode)
+          return nullptr;
+
+        next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part_view);
+        current_dentry->add_child(next_dentry);
       }
 
-      return current_dentry;
+      current_dentry = next_dentry;
     }
 
-    return nullptr;
+    return current_dentry;
   }
 
 }  // namespace filesystem
\ No newline at end of file
-- 
cgit v1.2.3


From fe964c2c9d3fb29223060f99c07ae1ce4e69daae Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 28 Mar 2026 19:14:02 +0100
Subject: set flag (currently not needed)

---
 kernel/src/filesystem/vfs.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index da7fa05..7a90531 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -111,6 +111,7 @@ namespace filesystem
     auto new_fs_root = kstd::make_shared<dentry>(mount_point_dentry, fs->root_inode());
     auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, path);
     m_mount_table.add_mount(new_mount);
+    mount_point_dentry->set_flag(dentry::dentry_flags::dcache_mounted);
   }
 
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
-- 
cgit v1.2.3


From 5603c7ec2b07dbc772fe2c20a9e9e176c5465c57 Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 30 Mar 2026 21:22:22 +0200
Subject: Move everything in kernel into kernel namespace

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 7a90531..2dbdb12 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -17,7 +17,7 @@
 #include <ranges>
 #include <string_view>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   namespace
   {
@@ -161,4 +161,4 @@ namespace filesystem
     return current_dentry;
   }
 
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
-- 
cgit v1.2.3


From 55e37a219fc953d1675bc2edb8573c6d47df7647 Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 30 Mar 2026 21:23:02 +0200
Subject: Rename ext2 filesystem files

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 2dbdb12..69740c3 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -5,7 +5,7 @@
 #include "kernel/devices/storage/storage_management.hpp"
 #include "kernel/filesystem/dentry.hpp"
 #include "kernel/filesystem/devfs/devfs_filesystem.hpp"
-#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+#include "kernel/filesystem/ext2/filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
@@ -47,7 +47,7 @@ namespace kernel::filesystem
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       // TODO BA-FS26 detect fs type from boot device and load corresponding fs, for now just assume ext2
-      auto boot_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
+      auto boot_root_fs = kstd::make_shared<ext2::filesystem>();
       boot_root_fs->mount(boot_device);
       do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
     }
-- 
cgit v1.2.3


From 0b5084780e4a89dcaccbda5823495c9cdd62b006 Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 30 Mar 2026 20:52:25 +0200
Subject: Rename devfs filesystem files

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 69740c3..fdad36c 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -4,7 +4,7 @@
 
 #include "kernel/devices/storage/storage_management.hpp"
 #include "kernel/filesystem/dentry.hpp"
-#include "kernel/filesystem/devfs/devfs_filesystem.hpp"
+#include "kernel/filesystem/devfs/filesystem.hpp"
 #include "kernel/filesystem/ext2/filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
@@ -52,7 +52,7 @@ namespace kernel::filesystem
       do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
     }
 
-    auto device_fs = kstd::make_shared<devfs::devfs_filesystem>();
+    auto device_fs = kstd::make_shared<devfs::filesystem>();
     device_fs->mount(nullptr);
     do_mount_internal("/dev", root_fs_root_dentry, device_fs);
   }
-- 
cgit v1.2.3


From 81ab0ba35d724dd465ed870e87047b3bf74cea13 Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 30 Mar 2026 21:01:18 +0200
Subject: Rename rootfs filesystem files

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index fdad36c..bee68e6 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -9,7 +9,7 @@
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
-#include "kernel/filesystem/rootfs/rootfs_filesystem.hpp"
+#include "kernel/filesystem/rootfs/filesystem.hpp"
 
 #include <kstd/memory>
 
@@ -37,7 +37,7 @@ namespace kernel::filesystem
 
   auto vfs::init_internal() -> void
   {
-    auto root_fs = kstd::make_shared<rootfs::rootfs_filesystem>();
+    auto root_fs = kstd::make_shared<rootfs::filesystem>();
     root_fs->mount(nullptr);
 
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode());
-- 
cgit v1.2.3


From 846135ba5cdfa545124b97c74182f5eada9a403a Mon Sep 17 00:00:00 2001
From: "marcel.braun" <marcel.braun@ost.ch>
Date: Mon, 30 Mar 2026 21:20:25 +0200
Subject: Rename ram_disk and storage files

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index bee68e6..06214d2 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -2,7 +2,7 @@
 
 #include "kapi/system.hpp"
 
-#include "kernel/devices/storage/storage_management.hpp"
+#include "kernel/devices/storage/management.hpp"
 #include "kernel/filesystem/dentry.hpp"
 #include "kernel/filesystem/devfs/filesystem.hpp"
 #include "kernel/filesystem/ext2/filesystem.hpp"
@@ -43,7 +43,7 @@ namespace kernel::filesystem
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode());
     m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, ""));
 
-    auto storage_mgmt = devices::storage::storage_management::get();
+    auto storage_mgmt = devices::storage::management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       // TODO BA-FS26 detect fs type from boot device and load corresponding fs, for now just assume ext2
-- 
cgit v1.2.3


From 72b40ecf33fb0ef2d4232b80560642296c79399c Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Thu, 2 Apr 2026 09:49:17 +0200
Subject: automatically detect the mounted file system type by trial-and-error

---
 kernel/src/filesystem/vfs.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 06214d2..66aa91e 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -5,7 +5,6 @@
 #include "kernel/devices/storage/management.hpp"
 #include "kernel/filesystem/dentry.hpp"
 #include "kernel/filesystem/devfs/filesystem.hpp"
-#include "kernel/filesystem/ext2/filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
@@ -46,9 +45,7 @@ namespace kernel::filesystem
     auto storage_mgmt = devices::storage::management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
-      // TODO BA-FS26 detect fs type from boot device and load corresponding fs, for now just assume ext2
-      auto boot_root_fs = kstd::make_shared<ext2::filesystem>();
-      boot_root_fs->mount(boot_device);
+      auto boot_root_fs = kernel::filesystem::filesystem::mount(boot_device);
       do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
     }
 
-- 
cgit v1.2.3


From 1dcf253fdf8169a3b2b71bfac68f2f25951af1a8 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Thu, 2 Apr 2026 10:04:04 +0200
Subject: fix build, refactoring

---
 kernel/src/filesystem/vfs.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 66aa91e..d611fc9 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -45,7 +45,7 @@ namespace kernel::filesystem
     auto storage_mgmt = devices::storage::management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
-      auto boot_root_fs = kernel::filesystem::filesystem::mount(boot_device);
+      auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device);
       do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
     }
 
-- 
cgit v1.2.3


From 2240b9a36e4a9f6f8291c9271e6aac8f5536dbd7 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 7 Apr 2026 22:13:49 +0200
Subject: refactoring

---
 kernel/src/filesystem/vfs.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index d611fc9..f9a051a 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -74,6 +74,7 @@ namespace kernel::filesystem
     return nullptr;
   }
 
+  // TODO BA-FS26 implement unmount
   auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> int
   {
     if (!filesystem)
-- 
cgit v1.2.3


From dd330e7a05905713acfa87ec109956bfe78f78c4 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Wed, 8 Apr 2026 09:31:32 +0200
Subject: add descriptions, some refactoring

---
 kernel/src/filesystem/vfs.cpp | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index f9a051a..2578036 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -21,6 +21,11 @@ namespace kernel::filesystem
   namespace
   {
     constinit auto static active_vfs = std::optional<vfs>{};
+
+    // Error codes
+    constexpr int INVALID_PATH = -1;
+    constexpr int MOUNT_POINT_NOT_FOUND = -2;
+    constexpr int FILESYSTEM_NULL = -3;
   }  // namespace
 
   auto vfs::init() -> void
@@ -79,18 +84,12 @@ namespace kernel::filesystem
   {
     if (!filesystem)
     {
-      return -1;  // TODO BA-FS26 panic or errorcode?
-    }
-
-    if (path.empty() || path.front() != '/')
-    {
-      return -1;  // TODO BA-FS26 panic or errorcode?
+      return FILESYSTEM_NULL;
     }
 
-    // TODO BA-FS26 better path validation
-    if ((path.size() > 1 && path.back() == '/'))
+    if (path.empty() || path.front() != '/' || (path.size() > 1 && path.back() == '/'))
     {
-      return -1;  // TODO BA-FS26 panic or errorcode?
+      return INVALID_PATH;
     }
 
     if (auto mount_point_dentry = resolve_path(path))
@@ -99,7 +98,7 @@ namespace kernel::filesystem
       return 0;
     }
 
-    return -1;
+    return MOUNT_POINT_NOT_FOUND;
   }
 
   auto vfs::do_mount_internal(std::string_view path, kstd::shared_ptr<dentry> const & mount_point_dentry,
-- 
cgit v1.2.3


From 2793770dc6eba30b73b4a4993618d2cbe184790e Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Wed, 8 Apr 2026 15:21:10 +0200
Subject: implement unmount, improve error codes

---
 kernel/src/filesystem/vfs.cpp | 45 ++++++++++++++++++++++++++++---------------
 1 file changed, 30 insertions(+), 15 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 2578036..45ae053 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -7,6 +7,7 @@
 #include "kernel/filesystem/devfs/filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
+#include "kernel/filesystem/mount_table.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
 #include "kernel/filesystem/rootfs/filesystem.hpp"
 
@@ -21,11 +22,6 @@ namespace kernel::filesystem
   namespace
   {
     constinit auto static active_vfs = std::optional<vfs>{};
-
-    // Error codes
-    constexpr int INVALID_PATH = -1;
-    constexpr int MOUNT_POINT_NOT_FOUND = -2;
-    constexpr int FILESYSTEM_NULL = -3;
   }  // namespace
 
   auto vfs::init() -> void
@@ -45,7 +41,7 @@ namespace kernel::filesystem
     root_fs->mount(nullptr);
 
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode());
-    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, ""));
+    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, "", nullptr));
 
     auto storage_mgmt = devices::storage::management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
@@ -79,36 +75,55 @@ namespace kernel::filesystem
     return nullptr;
   }
 
-  // TODO BA-FS26 implement unmount
-  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> int
+  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> operation_result
   {
     if (!filesystem)
     {
-      return FILESYSTEM_NULL;
+      return operation_result::filesystem_null;
     }
 
     if (path.empty() || path.front() != '/' || (path.size() > 1 && path.back() == '/'))
     {
-      return INVALID_PATH;
+      return operation_result::invalid_path;
     }
 
     if (auto mount_point_dentry = resolve_path(path))
     {
       do_mount_internal(path, mount_point_dentry, filesystem);
-      return 0;
+      return operation_result::success;
+    }
+
+    return operation_result::mount_point_not_found;
+  }
+
+  auto vfs::unmount(std::string_view path) -> operation_result
+  {
+    if (path.empty() || path.front() != '/' || (path.size() > 1 && path.back() == '/'))
+    {
+      return operation_result::invalid_path;
+    }
+
+    auto remove_result = m_mount_table.remove_mount(path);
+    if (remove_result == mount_table::operation_result::removed)
+    {
+      return operation_result::success;
+    }
+
+    if (remove_result == mount_table::operation_result::has_child_mounts)
+    {
+      return operation_result::unmount_failed;
     }
 
-    return MOUNT_POINT_NOT_FOUND;
+    return operation_result::mount_point_not_found;
   }
 
   auto vfs::do_mount_internal(std::string_view path, kstd::shared_ptr<dentry> const & mount_point_dentry,
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
-    // TODO BA-FS26 check if mount point is already mounted and handle it (unmount old fs, fail, etc.)
+    auto parent_mount = m_mount_table.find_longest_prefix_mount(path);
     auto new_fs_root = kstd::make_shared<dentry>(mount_point_dentry, fs->root_inode());
-    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, path);
+    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, path, parent_mount);
     m_mount_table.add_mount(new_mount);
-    mount_point_dentry->set_flag(dentry::dentry_flags::dcache_mounted);
   }
 
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
-- 
cgit v1.2.3


From 3c9ad45492d7417c65594fa7fa2fb9a8d5439276 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Thu, 9 Apr 2026 08:32:51 +0200
Subject: add deinit functions for singletons in tests

---
 kernel/src/filesystem/vfs.cpp | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 45ae053..67d1af2 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -17,13 +17,13 @@
 #include <ranges>
 #include <string_view>
 
-namespace kernel::filesystem
+namespace
 {
-  namespace
-  {
-    constinit auto static active_vfs = std::optional<vfs>{};
-  }  // namespace
+  constinit auto static active_vfs = std::optional<kernel::filesystem::vfs>{};
+}  // namespace
 
+namespace kernel::filesystem
+{
   auto vfs::init() -> void
   {
     if (active_vfs)
@@ -47,7 +47,10 @@ namespace kernel::filesystem
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device);
-      do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
+      if (boot_root_fs)
+      {
+        do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
+      }
     }
 
     auto device_fs = kstd::make_shared<devfs::filesystem>();
@@ -172,5 +175,12 @@ namespace kernel::filesystem
 
     return current_dentry;
   }
+}  // namespace kernel::filesystem
 
-}  // namespace kernel::filesystem
\ No newline at end of file
+namespace kernel::tests::filesystem::vfs
+{
+  auto deinit() -> void
+  {
+    active_vfs.reset();
+  }
+}  // namespace kernel::tests::filesystem::vfs
-- 
cgit v1.2.3


From 5e183b418b0e65dcdffa02a43702a0d6deb43b04 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Mon, 13 Apr 2026 21:17:50 +0200
Subject: Back filesystem by inode and not device

---
 kernel/src/filesystem/vfs.cpp | 39 +++++++++++++++++++--------------------
 1 file changed, 19 insertions(+), 20 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 67d1af2..394e926 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -2,7 +2,6 @@
 
 #include "kapi/system.hpp"
 
-#include "kernel/devices/storage/management.hpp"
 #include "kernel/filesystem/dentry.hpp"
 #include "kernel/filesystem/devfs/filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
@@ -43,19 +42,17 @@ namespace kernel::filesystem
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode());
     m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, "", nullptr));
 
-    auto storage_mgmt = devices::storage::management::get();
-    if (auto boot_device = storage_mgmt.determine_boot_device())
+    auto device_fs = kstd::make_shared<devfs::filesystem>();
+    device_fs->mount(nullptr);
+    do_mount_internal("/dev", root_fs_root_dentry, device_fs);
+
+    if (auto boot_device_dentry = resolve_path("/dev/ram0"))  // TODO BA-FS26 better boot device detection
     {
-      auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device);
-      if (boot_root_fs)
+      if (auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device_dentry->get_inode()))
       {
         do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
       }
     }
-
-    auto device_fs = kstd::make_shared<devfs::filesystem>();
-    device_fs->mount(nullptr);
-    do_mount_internal("/dev", root_fs_root_dentry, device_fs);
   }
 
   auto vfs::get() -> vfs &
@@ -78,24 +75,26 @@ namespace kernel::filesystem
     return nullptr;
   }
 
-  auto vfs::do_mount(std::string_view path, kstd::shared_ptr<filesystem> const & filesystem) -> operation_result
+  auto vfs::do_mount(std::string_view source, std::string_view target) -> operation_result
   {
-    if (!filesystem)
-    {
-      return operation_result::filesystem_null;
-    }
-
-    if (path.empty() || path.front() != '/' || (path.size() > 1 && path.back() == '/'))
+    if (target.empty() || target.front() != '/' || (target.size() > 1 && target.back() == '/'))
     {
       return operation_result::invalid_path;
     }
 
-    if (auto mount_point_dentry = resolve_path(path))
+    if (auto mount_point_dentry = resolve_path(target))
     {
-      do_mount_internal(path, mount_point_dentry, filesystem);
-      return operation_result::success;
+      if (auto source_dentry = resolve_path(source))
+      {
+        if (auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode()))
+        {
+          do_mount_internal(target, mount_point_dentry, fs);
+          return operation_result::success;
+        }
+        return operation_result::invalid_filesystem;
+      }
+      return operation_result::non_existent_path;
     }
-
     return operation_result::mount_point_not_found;
   }
 
-- 
cgit v1.2.3


From 1356405c9fc6d54cf9da4d5f6fd54c55d51ce66d Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sun, 19 Apr 2026 10:01:52 +0200
Subject: vfs open returns the dentry not the open file description

---
 kernel/src/filesystem/vfs.cpp | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 394e926..84c8047 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -7,7 +7,6 @@
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/mount_table.hpp"
-#include "kernel/filesystem/open_file_description.hpp"
 #include "kernel/filesystem/rootfs/filesystem.hpp"
 
 #include <kstd/memory>
@@ -65,14 +64,9 @@ namespace kernel::filesystem
     return *active_vfs;
   }
 
-  auto vfs::open(std::string_view path) -> kstd::shared_ptr<open_file_description>
+  auto vfs::open(std::string_view path) -> kstd::shared_ptr<dentry>
   {
-    if (auto dentry = resolve_path(path))
-    {
-      return kstd::make_shared<open_file_description>(dentry->get_inode());
-    }
-
-    return nullptr;
+    return resolve_path(path);
   }
 
   auto vfs::do_mount(std::string_view source, std::string_view target) -> operation_result
-- 
cgit v1.2.3


From 2d8fed40bd0d0f8144783b6b344dc79944291b72 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Thu, 23 Apr 2026 13:31:17 +0200
Subject: chore: organize includes

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 84c8047..23ced4c 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -1,7 +1,5 @@
 #include "kernel/filesystem/vfs.hpp"
 
-#include "kapi/system.hpp"
-
 #include "kernel/filesystem/dentry.hpp"
 #include "kernel/filesystem/devfs/filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
@@ -9,6 +7,8 @@
 #include "kernel/filesystem/mount_table.hpp"
 #include "kernel/filesystem/rootfs/filesystem.hpp"
 
+#include "kapi/system.hpp"
+
 #include <kstd/memory>
 
 #include <optional>
-- 
cgit v1.2.3


From f6f10575f75ac23d06e1d94f7861611503daa7af Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Thu, 23 Apr 2026 14:03:28 +0200
Subject: chore: banish relative includes

---
 kernel/src/filesystem/vfs.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 23ced4c..5b454f6 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -1,13 +1,13 @@
-#include "kernel/filesystem/vfs.hpp"
+#include <kernel/filesystem/vfs.hpp>
 
-#include "kernel/filesystem/dentry.hpp"
-#include "kernel/filesystem/devfs/filesystem.hpp"
-#include "kernel/filesystem/filesystem.hpp"
-#include "kernel/filesystem/mount.hpp"
-#include "kernel/filesystem/mount_table.hpp"
-#include "kernel/filesystem/rootfs/filesystem.hpp"
+#include <kernel/filesystem/dentry.hpp>
+#include <kernel/filesystem/devfs/filesystem.hpp>
+#include <kernel/filesystem/filesystem.hpp>
+#include <kernel/filesystem/mount.hpp>
+#include <kernel/filesystem/mount_table.hpp>
+#include <kernel/filesystem/rootfs/filesystem.hpp>
 
-#include "kapi/system.hpp"
+#include <kapi/system.hpp>
 
 #include <kstd/memory>
 
-- 
cgit v1.2.3


From 8550b6a1aacc2bfce733dcac7a44065b7e9116a1 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 2 May 2026 14:14:24 +0200
Subject: relative path support

---
 kernel/src/filesystem/vfs.cpp | 115 ++++++++++++++++++++++++++++++++++++------
 1 file changed, 100 insertions(+), 15 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 5b454f6..41afad3 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -10,6 +10,8 @@
 #include <kapi/system.hpp>
 
 #include <kstd/memory>
+#include <kstd/string>
+#include <kstd/vector>
 
 #include <optional>
 #include <ranges>
@@ -35,21 +37,38 @@ namespace kernel::filesystem
 
   auto vfs::init_internal() -> void
   {
+    // Mount rootfs at / as the temporary base
     auto root_fs = kstd::make_shared<rootfs::filesystem>();
     root_fs->mount(nullptr);
 
-    auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode());
-    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, "", nullptr));
+    auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
+    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, "/", nullptr));
 
+    // Mount devfs at /dev in rootfs (temporary, will be shadowed)
     auto device_fs = kstd::make_shared<devfs::filesystem>();
     device_fs->mount(nullptr);
-    do_mount_internal("/dev", root_fs_root_dentry, device_fs);
+    auto dev_mount_point_dentry = resolve_path("/dev");
+    if (!dev_mount_point_dentry)
+    {
+      kapi::system::panic("[FILESYSTEM] failed to resolve /dev for initial devfs mount.");
+    }
+    do_mount_internal("/dev", dev_mount_point_dentry, device_fs);
 
-    if (auto boot_device_dentry = resolve_path("/dev/ram0"))  // TODO BA-FS26 better boot device detection
+    // Mount boot filesystem at / (will shadow rootfs)
+    if (auto boot_device_dentry = resolve_path("/dev/ram0"))
     {
       if (auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device_dentry->get_inode()))
       {
         do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
+
+        // Resolve / to get the boot root dentry
+        if (auto boot_root_dentry = resolve_path("/"))
+        {
+          auto dev_dentry = kstd::make_shared<dentry>(boot_root_dentry, device_fs->root_inode(), "dev");
+          boot_root_dentry->add_child(dev_dentry);
+
+          do_mount_internal("/dev", dev_dentry, device_fs);
+        }
       }
     }
   }
@@ -117,33 +136,46 @@ namespace kernel::filesystem
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
     auto parent_mount = m_mount_table.find_longest_prefix_mount(path);
-    auto new_fs_root = kstd::make_shared<dentry>(mount_point_dentry, fs->root_inode());
+    auto new_fs_root =
+        kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
     auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, path, parent_mount);
     m_mount_table.add_mount(new_mount);
   }
 
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
   {
-    // TODO BA-FS26 implement full path resolution semantics.
     // TODO BA-FS26 better path validation
     // TODO BA-FS26 implement a path parser (maybe in libs?) and use it here and in do_mount
-
     if (path.empty() || path.front() != '/')
       return nullptr;
 
-    // TODO BA-FS26 longest match in mount_table -> jump into final fs directly
-    // TODO BA-FS26 performance optimization first check mounted_flag O(1) then check mount_table O(n)
-
-    auto best_mount = m_mount_table.find_longest_prefix_mount(path);
-    if (!best_mount)
+    auto current_mount = m_mount_table.find_longest_prefix_mount("/");
+    if (!current_mount)
     {
       kapi::system::panic("[FILESYSTEM] no root mount found.");
     }
 
-    auto current_dentry = best_mount->root_dentry();
-    auto current_fs = best_mount->get_filesystem();
+    auto current_dentry = current_mount->root_dentry();
+    kstd::vector<std::string_view> resolved_parts{};
+
+    // TODO BA-FS26 remove again an get path out of the dentires instead of building it up again here
+    auto build_resolved_path = [&resolved_parts]() {
+      kstd::string resolved_path{"/"};
+
+      for (auto const & resolved_part : resolved_parts)
+      {
+        if (resolved_path.size() > 1)
+        {
+          resolved_path += '/';
+        }
+
+        resolved_path += resolved_part;
+      }
 
-    std::string_view remaining = path.substr(best_mount->get_mount_path().size());
+      return resolved_path;
+    };
+
+    std::string_view remaining = path.substr(current_mount->get_mount_path().size());
 
     auto path_parts =
         std::views::split(remaining, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
@@ -152,9 +184,50 @@ namespace kernel::filesystem
     {
       std::string_view part_view{part};
 
+      if (part_view == ".")
+      {
+        continue;
+      }
+
+      if (part_view == "..")
+      {
+        if (!resolved_parts.empty())
+        {
+          resolved_parts.pop_back();
+        }
+
+        auto parent_dentry = current_dentry->get_parent();
+
+        if (current_dentry == current_mount->root_dentry())
+        {
+          // change the mount point
+          if (auto parent_mount = current_mount->get_parent_mount())
+          {
+            current_mount = parent_mount;
+            current_dentry = current_dentry->get_parent();
+
+            if (!parent_dentry)
+            {
+              parent_dentry = current_mount->root_dentry();
+            }
+          }
+        }
+
+        if (!parent_dentry)
+        {
+          return nullptr;
+        }
+
+        current_dentry = parent_dentry;
+        continue;
+      }
+
+      resolved_parts.push_back(part_view);
+
       auto next_dentry = current_dentry->find_child(part_view);
       if (!next_dentry)
       {
+        auto current_fs = current_mount->get_filesystem();
         auto found_inode = current_fs->lookup(current_dentry->get_inode(), part_view);
         if (!found_inode)
           return nullptr;
@@ -162,6 +235,18 @@ namespace kernel::filesystem
         next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part_view);
         current_dentry->add_child(next_dentry);
       }
+      else if (next_dentry->has_flag(dentry::dentry_flags::mounted))
+      {
+        // change the mount point
+        // TODO BA-FS26 get resolved path out of the dentry...
+        current_mount = m_mount_table.find_longest_prefix_mount(build_resolved_path().view());
+        if (!current_mount)
+        {
+          kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
+        }
+
+        next_dentry = current_mount->root_dentry();
+      }
 
       current_dentry = next_dentry;
     }
-- 
cgit v1.2.3


From d3c8b74020bfeee554394b7e41c58d5ddda6f396 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 2 May 2026 14:23:19 +0200
Subject: refactoring

---
 kernel/src/filesystem/vfs.cpp | 32 ++------------------------------
 1 file changed, 2 insertions(+), 30 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 41afad3..9a6625d 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -11,7 +11,6 @@
 
 #include <kstd/memory>
 #include <kstd/string>
-#include <kstd/vector>
 
 #include <optional>
 #include <ranges>
@@ -156,25 +155,6 @@ namespace kernel::filesystem
     }
 
     auto current_dentry = current_mount->root_dentry();
-    kstd::vector<std::string_view> resolved_parts{};
-
-    // TODO BA-FS26 remove again an get path out of the dentires instead of building it up again here
-    auto build_resolved_path = [&resolved_parts]() {
-      kstd::string resolved_path{"/"};
-
-      for (auto const & resolved_part : resolved_parts)
-      {
-        if (resolved_path.size() > 1)
-        {
-          resolved_path += '/';
-        }
-
-        resolved_path += resolved_part;
-      }
-
-      return resolved_path;
-    };
-
     std::string_view remaining = path.substr(current_mount->get_mount_path().size());
 
     auto path_parts =
@@ -191,11 +171,6 @@ namespace kernel::filesystem
 
       if (part_view == "..")
       {
-        if (!resolved_parts.empty())
-        {
-          resolved_parts.pop_back();
-        }
-
         auto parent_dentry = current_dentry->get_parent();
 
         if (current_dentry == current_mount->root_dentry())
@@ -222,8 +197,6 @@ namespace kernel::filesystem
         continue;
       }
 
-      resolved_parts.push_back(part_view);
-
       auto next_dentry = current_dentry->find_child(part_view);
       if (!next_dentry)
       {
@@ -237,9 +210,8 @@ namespace kernel::filesystem
       }
       else if (next_dentry->has_flag(dentry::dentry_flags::mounted))
       {
-        // change the mount point
-        // TODO BA-FS26 get resolved path out of the dentry...
-        current_mount = m_mount_table.find_longest_prefix_mount(build_resolved_path().view());
+        // TODO BA-FS26 really do it like this? or just call "get" without longes_prefix stuff
+        current_mount = m_mount_table.find_longest_prefix_mount(next_dentry->get_full_path().view());
         if (!current_mount)
         {
           kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
-- 
cgit v1.2.3


From e74e56559ae99fd14715371ebceb2545f68008de Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 2 May 2026 14:24:46 +0200
Subject: add todos

---
 kernel/src/filesystem/vfs.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 9a6625d..a3da258 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -89,6 +89,7 @@ namespace kernel::filesystem
 
   auto vfs::do_mount(std::string_view source, std::string_view target) -> operation_result
   {
+    // TODO BA-FS26 better path validation
     if (target.empty() || target.front() != '/' || (target.size() > 1 && target.back() == '/'))
     {
       return operation_result::invalid_path;
@@ -112,6 +113,7 @@ namespace kernel::filesystem
 
   auto vfs::unmount(std::string_view path) -> operation_result
   {
+    // TODO BA-FS26 better path validation
     if (path.empty() || path.front() != '/' || (path.size() > 1 && path.back() == '/'))
     {
       return operation_result::invalid_path;
-- 
cgit v1.2.3


From 1269410c4c733ed38859b3e70713728afb273443 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Sun, 3 May 2026 15:01:49 +0200
Subject: Use iterator in path resolution, start with symlink implementation

---
 kernel/src/filesystem/vfs.cpp | 40 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 37 insertions(+), 3 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index a3da258..ba4f404 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -94,7 +94,7 @@ namespace kernel::filesystem
     {
       return operation_result::invalid_path;
     }
-
+    // TODO BA-FS26 check if target is directory?
     if (auto mount_point_dentry = resolve_path(target))
     {
       if (auto source_dentry = resolve_path(source))
@@ -162,9 +162,9 @@ namespace kernel::filesystem
     auto path_parts =
         std::views::split(remaining, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
 
-    for (auto const & part : path_parts)
+    for (auto it = path_parts.begin(); it != path_parts.end(); ++it)
     {
-      std::string_view part_view{part};
+      std::string_view part_view{*it};
 
       if (part_view == ".")
       {
@@ -205,7 +205,9 @@ namespace kernel::filesystem
         auto current_fs = current_mount->get_filesystem();
         auto found_inode = current_fs->lookup(current_dentry->get_inode(), part_view);
         if (!found_inode)
+        {
           return nullptr;
+        }
 
         next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part_view);
         current_dentry->add_child(next_dentry);
@@ -222,6 +224,38 @@ namespace kernel::filesystem
         next_dentry = current_mount->root_dentry();
       }
 
+      if (next_dentry->get_inode()->is_symbolic_link())
+      {
+        // TODO BA-FS26 this for loop is ugly --> fix
+        kstd::string symlink_path = "halo";
+        if (symlink_path.size() > 0 && symlink_path.front() == '/')
+        {
+          for (auto it2 = std::next(it); it2 != path_parts.end(); ++it2)
+          {
+            symlink_path += "/";
+            symlink_path.append(std::string_view{*it2});
+          }
+          return resolve_path(symlink_path.view());
+        }
+        else
+        {
+          kstd::string combined;
+          for (auto it3 = path_parts.begin(); it3 != it; ++it3)
+          {
+            combined += "/";
+            combined.append(std::string_view{*it3});
+          }
+          combined += "/";
+          combined += symlink_path;
+          for (auto it4 = std::next(it); it4 != path_parts.end(); ++it4)
+          {
+            combined += "/";
+            combined.append(std::string_view{*it4});
+          }
+          return resolve_path(combined.view());
+        }
+      }
+
       current_dentry = next_dentry;
     }
 
-- 
cgit v1.2.3


From 7ff97f0fe861bb7382f41ecd4bab26cbb62b1f7d Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Mon, 4 May 2026 19:47:57 +0200
Subject: Resolve TODOs concerning path validation

---
 kernel/src/filesystem/vfs.cpp | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index ba4f404..8f48820 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -5,6 +5,7 @@
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/mount.hpp>
 #include <kernel/filesystem/mount_table.hpp>
+#include <kernel/filesystem/path.hpp>
 #include <kernel/filesystem/rootfs/filesystem.hpp>
 
 #include <kapi/system.hpp>
@@ -89,12 +90,11 @@ namespace kernel::filesystem
 
   auto vfs::do_mount(std::string_view source, std::string_view target) -> operation_result
   {
-    // TODO BA-FS26 better path validation
-    if (target.empty() || target.front() != '/' || (target.size() > 1 && target.back() == '/'))
+    if (!kernel::filesystem::path::is_valid_path(source) || !kernel::filesystem::path::is_valid_path(target))
     {
       return operation_result::invalid_path;
     }
-    // TODO BA-FS26 check if target is directory?
+
     if (auto mount_point_dentry = resolve_path(target))
     {
       if (auto source_dentry = resolve_path(source))
@@ -113,8 +113,7 @@ namespace kernel::filesystem
 
   auto vfs::unmount(std::string_view path) -> operation_result
   {
-    // TODO BA-FS26 better path validation
-    if (path.empty() || path.front() != '/' || (path.size() > 1 && path.back() == '/'))
+    if (!kernel::filesystem::path::is_valid_path(path))
     {
       return operation_result::invalid_path;
     }
@@ -145,11 +144,12 @@ namespace kernel::filesystem
 
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
   {
-    // TODO BA-FS26 better path validation
-    // TODO BA-FS26 implement a path parser (maybe in libs?) and use it here and in do_mount
-    if (path.empty() || path.front() != '/')
+    if (!kernel::filesystem::path::is_valid_absolute_path(path))
+    {
       return nullptr;
+    }
 
+    // TODO BA-FS26 refactor (get mount by path, no more prefix matching)
     auto current_mount = m_mount_table.find_longest_prefix_mount("/");
     if (!current_mount)
     {
@@ -157,10 +157,8 @@ namespace kernel::filesystem
     }
 
     auto current_dentry = current_mount->root_dentry();
-    std::string_view remaining = path.substr(current_mount->get_mount_path().size());
 
-    auto path_parts =
-        std::views::split(remaining, '/') | std::views::filter([](auto const & part) { return !part.empty(); });
+    auto path_parts = kernel::filesystem::path::split(path);
 
     for (auto it = path_parts.begin(); it != path_parts.end(); ++it)
     {
-- 
cgit v1.2.3


From d1e64340abb960c579651635d580660c12f94e6e Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Mon, 4 May 2026 20:31:58 +0200
Subject: Refactor path resolution, use vector and while instead of iterator
 and for-loop

---
 kernel/src/filesystem/vfs.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 8f48820..c9939fa 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -12,7 +12,9 @@
 
 #include <kstd/memory>
 #include <kstd/string>
+#include <kstd/vector>
 
+#include <algorithm>
 #include <optional>
 #include <ranges>
 #include <string_view>
@@ -159,10 +161,13 @@ namespace kernel::filesystem
     auto current_dentry = current_mount->root_dentry();
 
     auto path_parts = kernel::filesystem::path::split(path);
+    kstd::vector path_parts_vector(path_parts.begin(), path_parts.end());
+    std::ranges::reverse(path_parts_vector);
 
-    for (auto it = path_parts.begin(); it != path_parts.end(); ++it)
+    while (!path_parts_vector.empty())
     {
-      std::string_view part_view{*it};
+      std::string_view part_view{path_parts_vector.back()};
+      path_parts_vector.pop_back();
 
       if (part_view == ".")
       {
-- 
cgit v1.2.3


From bddee0f0cb77eb247eceea18005dc575b433bb69 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Mon, 4 May 2026 20:51:49 +0200
Subject: Implement symlink non-recursive

---
 kernel/src/filesystem/vfs.cpp | 41 +++++++++++++++--------------------------
 1 file changed, 15 insertions(+), 26 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index c9939fa..06d36ce 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -15,6 +15,7 @@
 #include <kstd/vector>
 
 #include <algorithm>
+#include <cstdint>
 #include <optional>
 #include <ranges>
 #include <string_view>
@@ -229,33 +230,21 @@ namespace kernel::filesystem
 
       if (next_dentry->get_inode()->is_symbolic_link())
       {
-        // TODO BA-FS26 this for loop is ugly --> fix
-        kstd::string symlink_path = "halo";
-        if (symlink_path.size() > 0 && symlink_path.front() == '/')
-        {
-          for (auto it2 = std::next(it); it2 != path_parts.end(); ++it2)
-          {
-            symlink_path += "/";
-            symlink_path.append(std::string_view{*it2});
-          }
-          return resolve_path(symlink_path.view());
-        }
-        else
+        // TODO BA-FS26 max symbolic link depth to prevent infinite loops
+        kstd::vector<uint8_t> buffer(4096);  // TODO BA-FS26 max symlink size?
+        auto const bytes_read = next_dentry->get_inode()->read(buffer.data(), 0, buffer.size());
+        auto const symbolic_link_path = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};
+
+        auto symbolic_link_parts = kernel::filesystem::path::split(symbolic_link_path);
+        kstd::vector symbolic_link_parts_vector(symbolic_link_parts.begin(), symbolic_link_parts.end());
+        std::ranges::reverse(symbolic_link_parts_vector);
+
+        path_parts_vector.insert_range(path_parts_vector.end(), symbolic_link_parts_vector);
+
+        if (kernel::filesystem::path::is_valid_absolute_path(symbolic_link_path))
         {
-          kstd::string combined;
-          for (auto it3 = path_parts.begin(); it3 != it; ++it3)
-          {
-            combined += "/";
-            combined.append(std::string_view{*it3});
-          }
-          combined += "/";
-          combined += symlink_path;
-          for (auto it4 = std::next(it); it4 != path_parts.end(); ++it4)
-          {
-            combined += "/";
-            combined.append(std::string_view{*it4});
-          }
-          return resolve_path(combined.view());
+          current_mount = m_mount_table.find_longest_prefix_mount("/");
+          next_dentry = current_mount->root_dentry();
         }
       }
 
-- 
cgit v1.2.3


From 2ab9d6ffbc4aad8ab3a393bd32191e3c07103c0a Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 5 May 2026 14:37:47 +0200
Subject: fix problem with string_view lifetime

---
 kernel/src/filesystem/vfs.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 06d36ce..03921df 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -167,15 +167,15 @@ namespace kernel::filesystem
 
     while (!path_parts_vector.empty())
     {
-      std::string_view part_view{path_parts_vector.back()};
+      auto part = path_parts_vector.back();
       path_parts_vector.pop_back();
 
-      if (part_view == ".")
+      if (part == ".")
       {
         continue;
       }
 
-      if (part_view == "..")
+      if (part == "..")
       {
         auto parent_dentry = current_dentry->get_parent();
 
@@ -203,17 +203,17 @@ namespace kernel::filesystem
         continue;
       }
 
-      auto next_dentry = current_dentry->find_child(part_view);
+      auto next_dentry = current_dentry->find_child(part.view());
       if (!next_dentry)
       {
         auto current_fs = current_mount->get_filesystem();
-        auto found_inode = current_fs->lookup(current_dentry->get_inode(), part_view);
+        auto found_inode = current_fs->lookup(current_dentry->get_inode(), part.view());
         if (!found_inode)
         {
           return nullptr;
         }
 
-        next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part_view);
+        next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part.view());
         current_dentry->add_child(next_dentry);
       }
       else if (next_dentry->has_flag(dentry::dentry_flags::mounted))
@@ -244,8 +244,9 @@ namespace kernel::filesystem
         if (kernel::filesystem::path::is_valid_absolute_path(symbolic_link_path))
         {
           current_mount = m_mount_table.find_longest_prefix_mount("/");
-          next_dentry = current_mount->root_dentry();
+          current_dentry = current_mount->root_dentry();
         }
+        continue;
       }
 
       current_dentry = next_dentry;
-- 
cgit v1.2.3


From b6cc02c3bac002ebac8e6ba734b00f0e60b24778 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Tue, 5 May 2026 16:05:48 +0200
Subject: Add check for max symlink count

---
 kernel/src/filesystem/vfs.cpp | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 03921df..e6d9241 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -1,5 +1,6 @@
 #include <kernel/filesystem/vfs.hpp>
 
+#include <kernel/filesystem/constants.hpp>
 #include <kernel/filesystem/dentry.hpp>
 #include <kernel/filesystem/devfs/filesystem.hpp>
 #include <kernel/filesystem/filesystem.hpp>
@@ -93,7 +94,7 @@ namespace kernel::filesystem
 
   auto vfs::do_mount(std::string_view source, std::string_view target) -> operation_result
   {
-    if (!kernel::filesystem::path::is_valid_path(source) || !kernel::filesystem::path::is_valid_path(target))
+    if (!path::is_valid_path(source) || !path::is_valid_path(target))
     {
       return operation_result::invalid_path;
     }
@@ -116,7 +117,7 @@ namespace kernel::filesystem
 
   auto vfs::unmount(std::string_view path) -> operation_result
   {
-    if (!kernel::filesystem::path::is_valid_path(path))
+    if (!path::is_valid_path(path))
     {
       return operation_result::invalid_path;
     }
@@ -147,7 +148,7 @@ namespace kernel::filesystem
 
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
   {
-    if (!kernel::filesystem::path::is_valid_absolute_path(path))
+    if (!path::is_valid_absolute_path(path))
     {
       return nullptr;
     }
@@ -161,10 +162,12 @@ namespace kernel::filesystem
 
     auto current_dentry = current_mount->root_dentry();
 
-    auto path_parts = kernel::filesystem::path::split(path);
+    auto path_parts = path::split(path);
     kstd::vector path_parts_vector(path_parts.begin(), path_parts.end());
     std::ranges::reverse(path_parts_vector);
 
+    auto symlink_counter = 0uz;
+
     while (!path_parts_vector.empty())
     {
       auto part = path_parts_vector.back();
@@ -230,18 +233,22 @@ namespace kernel::filesystem
 
       if (next_dentry->get_inode()->is_symbolic_link())
       {
-        // TODO BA-FS26 max symbolic link depth to prevent infinite loops
-        kstd::vector<uint8_t> buffer(4096);  // TODO BA-FS26 max symlink size?
+        if (symlink_counter++ > constants::symloop_max)
+        {
+          return nullptr;
+        }
+
+        kstd::vector<uint8_t> buffer(constants::symlink_max_path_length);
         auto const bytes_read = next_dentry->get_inode()->read(buffer.data(), 0, buffer.size());
         auto const symbolic_link_path = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};
 
-        auto symbolic_link_parts = kernel::filesystem::path::split(symbolic_link_path);
+        auto symbolic_link_parts = path::split(symbolic_link_path);
         kstd::vector symbolic_link_parts_vector(symbolic_link_parts.begin(), symbolic_link_parts.end());
         std::ranges::reverse(symbolic_link_parts_vector);
 
         path_parts_vector.insert_range(path_parts_vector.end(), symbolic_link_parts_vector);
 
-        if (kernel::filesystem::path::is_valid_absolute_path(symbolic_link_path))
+        if (path::is_valid_absolute_path(symbolic_link_path))
         {
           current_mount = m_mount_table.find_longest_prefix_mount("/");
           current_dentry = current_mount->root_dentry();
-- 
cgit v1.2.3


From 265ac82029665921bd95d74411682968ee0d4ada Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 5 May 2026 19:41:50 +0200
Subject: refactoring do_mount_internal (retrieve path from dentry), handle ..
 correctly in relative path

---
 kernel/src/filesystem/vfs.cpp | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index e6d9241..4defc81 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -56,14 +56,14 @@ namespace kernel::filesystem
     {
       kapi::system::panic("[FILESYSTEM] failed to resolve /dev for initial devfs mount.");
     }
-    do_mount_internal("/dev", dev_mount_point_dentry, device_fs);
+    do_mount_internal(dev_mount_point_dentry, device_fs);
 
     // Mount boot filesystem at / (will shadow rootfs)
     if (auto boot_device_dentry = resolve_path("/dev/ram0"))
     {
       if (auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device_dentry->get_inode()))
       {
-        do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
+        do_mount_internal(root_fs_root_dentry, boot_root_fs);
 
         // Resolve / to get the boot root dentry
         if (auto boot_root_dentry = resolve_path("/"))
@@ -71,7 +71,7 @@ namespace kernel::filesystem
           auto dev_dentry = kstd::make_shared<dentry>(boot_root_dentry, device_fs->root_inode(), "dev");
           boot_root_dentry->add_child(dev_dentry);
 
-          do_mount_internal("/dev", dev_dentry, device_fs);
+          do_mount_internal(dev_dentry, device_fs);
         }
       }
     }
@@ -105,7 +105,7 @@ namespace kernel::filesystem
       {
         if (auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode()))
         {
-          do_mount_internal(target, mount_point_dentry, fs);
+          do_mount_internal(mount_point_dentry, fs);
           return operation_result::success;
         }
         return operation_result::invalid_filesystem;
@@ -136,13 +136,15 @@ namespace kernel::filesystem
     return operation_result::mount_point_not_found;
   }
 
-  auto vfs::do_mount_internal(std::string_view path, kstd::shared_ptr<dentry> const & mount_point_dentry,
+  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
-    auto parent_mount = m_mount_table.find_longest_prefix_mount(path);
+    auto mount_path = mount_point_dentry->get_full_path();
+
+    auto parent_mount = m_mount_table.find_longest_prefix_mount(mount_path.view());
     auto new_fs_root =
         kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
-    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, path, parent_mount);
+    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, mount_path.view(), parent_mount);
     m_mount_table.add_mount(new_mount);
   }
 
@@ -188,16 +190,15 @@ namespace kernel::filesystem
           if (auto parent_mount = current_mount->get_parent_mount())
           {
             current_mount = parent_mount;
-            current_dentry = current_dentry->get_parent();
+            current_dentry = parent_dentry;
+          }
 
-            if (!parent_dentry)
-            {
-              parent_dentry = current_mount->root_dentry();
-            }
+          if (!parent_dentry)
+          {
+            parent_dentry = current_mount->root_dentry();
           }
         }
-
-        if (!parent_dentry)
+        else if (!parent_dentry)
         {
           return nullptr;
         }
-- 
cgit v1.2.3


From b7fba373341dd44b53642d7233396efbef4526b2 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 5 May 2026 20:07:37 +0200
Subject: avoid to traverse back over the root

---
 kernel/src/filesystem/vfs.cpp | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 4defc81..7f21a5c 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -186,22 +186,17 @@ namespace kernel::filesystem
 
         if (current_dentry == current_mount->root_dentry())
         {
-          // change the mount point
-          if (auto parent_mount = current_mount->get_parent_mount())
+          if (current_mount->get_mount_path() == "/")
           {
-            current_mount = parent_mount;
-            current_dentry = parent_dentry;
+            continue;
           }
 
-          if (!parent_dentry)
+          if (auto parent_mount = current_mount->get_parent_mount())
           {
-            parent_dentry = current_mount->root_dentry();
+            current_mount = parent_mount;
+            current_dentry = parent_dentry;
           }
         }
-        else if (!parent_dentry)
-        {
-          return nullptr;
-        }
 
         current_dentry = parent_dentry;
         continue;
-- 
cgit v1.2.3


From 7414148b662a33cf6c69f89b7b0c3162f6880d6c Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 5 May 2026 20:33:28 +0200
Subject: refactoring mount_table lookup

---
 kernel/src/filesystem/vfs.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 7f21a5c..19f5f48 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -41,7 +41,6 @@ namespace kernel::filesystem
 
   auto vfs::init_internal() -> void
   {
-    // Mount rootfs at / as the temporary base
     auto root_fs = kstd::make_shared<rootfs::filesystem>();
     root_fs->mount(nullptr);
 
@@ -140,8 +139,8 @@ namespace kernel::filesystem
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
     auto mount_path = mount_point_dentry->get_full_path();
-
     auto parent_mount = m_mount_table.find_longest_prefix_mount(mount_path.view());
+
     auto new_fs_root =
         kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
     auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, mount_path.view(), parent_mount);
@@ -156,7 +155,7 @@ namespace kernel::filesystem
     }
 
     // TODO BA-FS26 refactor (get mount by path, no more prefix matching)
-    auto current_mount = m_mount_table.find_longest_prefix_mount("/");
+    auto current_mount = m_mount_table.find_exact_mount("/");
     if (!current_mount)
     {
       kapi::system::panic("[FILESYSTEM] no root mount found.");
@@ -217,8 +216,7 @@ namespace kernel::filesystem
       }
       else if (next_dentry->has_flag(dentry::dentry_flags::mounted))
       {
-        // TODO BA-FS26 really do it like this? or just call "get" without longes_prefix stuff
-        current_mount = m_mount_table.find_longest_prefix_mount(next_dentry->get_full_path().view());
+        current_mount = m_mount_table.find_exact_mount(next_dentry->get_full_path().view());
         if (!current_mount)
         {
           kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
@@ -246,7 +244,7 @@ namespace kernel::filesystem
 
         if (path::is_valid_absolute_path(symbolic_link_path))
         {
-          current_mount = m_mount_table.find_longest_prefix_mount("/");
+          current_mount = m_mount_table.find_exact_mount("/");
           current_dentry = current_mount->root_dentry();
         }
         continue;
-- 
cgit v1.2.3


From 7ccfa26a3dde4d4266f8c59f4e3de8bd6f760059 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 5 May 2026 21:17:23 +0200
Subject: small refactoring, add todo

---
 kernel/src/filesystem/vfs.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 19f5f48..b84f690 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -139,6 +139,7 @@ namespace kernel::filesystem
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
     auto mount_path = mount_point_dentry->get_full_path();
+    // TODO BA-FS26 refactoring, implement dentry lookup to get the parent mount...
     auto parent_mount = m_mount_table.find_longest_prefix_mount(mount_path.view());
 
     auto new_fs_root =
-- 
cgit v1.2.3


From 870039d48d28f479eea88c7548b8d2b2a28c09bc Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 5 May 2026 21:18:48 +0200
Subject: add mount table find_exact_mount tests, remove todo

---
 kernel/src/filesystem/vfs.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index b84f690..519550b 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -155,7 +155,6 @@ namespace kernel::filesystem
       return nullptr;
     }
 
-    // TODO BA-FS26 refactor (get mount by path, no more prefix matching)
     auto current_mount = m_mount_table.find_exact_mount("/");
     if (!current_mount)
     {
-- 
cgit v1.2.3


From a4c9b9bdb768ce20c9f9eac353a34598e4a422a9 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Mon, 11 May 2026 18:54:27 +0200
Subject: Rename get_full_path to get_absolute_path

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 519550b..1410b2a 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -138,7 +138,7 @@ namespace kernel::filesystem
   auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
-    auto mount_path = mount_point_dentry->get_full_path();
+    auto mount_path = mount_point_dentry->get_absolute_path();
     // TODO BA-FS26 refactoring, implement dentry lookup to get the parent mount...
     auto parent_mount = m_mount_table.find_longest_prefix_mount(mount_path.view());
 
@@ -216,7 +216,7 @@ namespace kernel::filesystem
       }
       else if (next_dentry->has_flag(dentry::dentry_flags::mounted))
       {
-        current_mount = m_mount_table.find_exact_mount(next_dentry->get_full_path().view());
+        current_mount = m_mount_table.find_exact_mount(next_dentry->get_absolute_path().view());
         if (!current_mount)
         {
           kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
-- 
cgit v1.2.3


From 00aa2c8695b81944798010d81d600038e1f1ef3d Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sun, 10 May 2026 19:08:07 +0200
Subject: remove mount_path from mount struct (retrieve path from
 m_mount_dentry)

---
 kernel/src/filesystem/vfs.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 1410b2a..ea060a9 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -45,7 +45,7 @@ namespace kernel::filesystem
     root_fs->mount(nullptr);
 
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
-    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, "/", nullptr));
+    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, nullptr));
 
     // Mount devfs at /dev in rootfs (temporary, will be shadowed)
     auto device_fs = kstd::make_shared<devfs::filesystem>();
@@ -142,9 +142,12 @@ namespace kernel::filesystem
     // TODO BA-FS26 refactoring, implement dentry lookup to get the parent mount...
     auto parent_mount = m_mount_table.find_longest_prefix_mount(mount_path.view());
 
+    // auto parent_mount_dentry = mount_point_dentry->get_parent_mounted_dentry();
+    // auto parent_mount = m_mount_table.find_exact_mount(parent_mount_dentry->get_full_path());
+
     auto new_fs_root =
         kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
-    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, mount_path.view(), parent_mount);
+    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
     m_mount_table.add_mount(new_mount);
   }
 
-- 
cgit v1.2.3


From 85fd2e3b4da7d84a9357b35bde740b780fe0cb72 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Sun, 10 May 2026 21:49:20 +0200
Subject: Rename root_dentry() to get_root_dentry()

---
 kernel/src/filesystem/vfs.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index ea060a9..2b8c3bd 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -164,7 +164,7 @@ namespace kernel::filesystem
       kapi::system::panic("[FILESYSTEM] no root mount found.");
     }
 
-    auto current_dentry = current_mount->root_dentry();
+    auto current_dentry = current_mount->get_root_dentry();
 
     auto path_parts = path::split(path);
     kstd::vector path_parts_vector(path_parts.begin(), path_parts.end());
@@ -186,7 +186,7 @@ namespace kernel::filesystem
       {
         auto parent_dentry = current_dentry->get_parent();
 
-        if (current_dentry == current_mount->root_dentry())
+        if (current_dentry == current_mount->get_root_dentry())
         {
           if (current_mount->get_mount_path() == "/")
           {
@@ -225,7 +225,7 @@ namespace kernel::filesystem
           kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
         }
 
-        next_dentry = current_mount->root_dentry();
+        next_dentry = current_mount->get_root_dentry();
       }
 
       if (next_dentry->get_inode()->is_symbolic_link())
@@ -248,7 +248,7 @@ namespace kernel::filesystem
         if (path::is_valid_absolute_path(symbolic_link_path))
         {
           current_mount = m_mount_table.find_exact_mount("/");
-          current_dentry = current_mount->root_dentry();
+          current_dentry = current_mount->get_root_dentry();
         }
         continue;
       }
-- 
cgit v1.2.3


From 636551d03ac725e015dd88631d531c02067ed3de Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Sun, 10 May 2026 21:51:11 +0200
Subject: Create first draft of get_parent_mount without
 find_longest_prefix_mount

---
 kernel/src/filesystem/vfs.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 2b8c3bd..e7f9015 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -138,13 +138,13 @@ namespace kernel::filesystem
   auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
-    auto mount_path = mount_point_dentry->get_absolute_path();
-    // TODO BA-FS26 refactoring, implement dentry lookup to get the parent mount...
-    auto parent_mount = m_mount_table.find_longest_prefix_mount(mount_path.view());
-
-    // auto parent_mount_dentry = mount_point_dentry->get_parent_mounted_dentry();
-    // auto parent_mount = m_mount_table.find_exact_mount(parent_mount_dentry->get_full_path());
-
+    auto parent_mount_dentry = mount_point_dentry->get_ancestor_with_mount_flag();
+    kstd::shared_ptr<mount> parent_mount = nullptr;
+    if (parent_mount_dentry)
+    {
+      parent_mount = m_mount_table.find_exact_mount(parent_mount_dentry->get_absolute_path().view());
+    }
+    
     auto new_fs_root =
         kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
     auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
-- 
cgit v1.2.3


From 5d72c256d4e2b8a9d2fd70e5a27e883a0f733e50 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Mon, 11 May 2026 20:48:03 +0200
Subject: Add is_mount_root flag to dentry and use in find_mount_root_dentry

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index e7f9015..ee7c262 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -138,7 +138,7 @@ namespace kernel::filesystem
   auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
                               kstd::shared_ptr<filesystem> const & fs) -> void
   {
-    auto parent_mount_dentry = mount_point_dentry->get_ancestor_with_mount_flag();
+    auto parent_mount_dentry = mount_point_dentry->find_mount_root_dentry();
     kstd::shared_ptr<mount> parent_mount = nullptr;
     if (parent_mount_dentry)
     {
@@ -217,7 +217,7 @@ namespace kernel::filesystem
         next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part.view());
         current_dentry->add_child(next_dentry);
       }
-      else if (next_dentry->has_flag(dentry::dentry_flags::mounted))
+      else if (next_dentry->has_flag(dentry::dentry_flags::is_mount_point))
       {
         current_mount = m_mount_table.find_exact_mount(next_dentry->get_absolute_path().view());
         if (!current_mount)
-- 
cgit v1.2.3


From 91821da0110e05724640903434c3d85fc3d02466 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Tue, 12 May 2026 12:00:40 +0200
Subject: if the boot_root_fs contains a /dev directory, vfs mounts the devfs
 onto the existing directory

---
 kernel/src/filesystem/vfs.cpp | 40 +++++++++++++++++++++++++++-------------
 1 file changed, 27 insertions(+), 13 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index ee7c262..535f898 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -41,36 +41,35 @@ namespace kernel::filesystem
 
   auto vfs::init_internal() -> void
   {
+    // mount rootfs at /
     auto root_fs = kstd::make_shared<rootfs::filesystem>();
     root_fs->mount(nullptr);
 
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
     m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, nullptr));
 
-    // Mount devfs at /dev in rootfs (temporary, will be shadowed)
+    // mount devfs at /dev (inside rootfs, temporary, will be shadowed)
     auto device_fs = kstd::make_shared<devfs::filesystem>();
     device_fs->mount(nullptr);
-    auto dev_mount_point_dentry = resolve_path("/dev");
-    if (!dev_mount_point_dentry)
+
+    if (auto dev_mount_point_dentry = resolve_path("/dev"))
+    {
+      do_mount_internal(dev_mount_point_dentry, device_fs);
+    }
+    else
     {
       kapi::system::panic("[FILESYSTEM] failed to resolve /dev for initial devfs mount.");
     }
-    do_mount_internal(dev_mount_point_dentry, device_fs);
 
-    // Mount boot filesystem at / (will shadow rootfs)
+    // mount boot fs at / (shadows rootfs), re-graft devfs
     if (auto boot_device_dentry = resolve_path("/dev/ram0"))
     {
       if (auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device_dentry->get_inode()))
       {
-        do_mount_internal(root_fs_root_dentry, boot_root_fs);
-
-        // Resolve / to get the boot root dentry
-        if (auto boot_root_dentry = resolve_path("/"))
+        if (auto root_dentry = resolve_path("/"))
         {
-          auto dev_dentry = kstd::make_shared<dentry>(boot_root_dentry, device_fs->root_inode(), "dev");
-          boot_root_dentry->add_child(dev_dentry);
-
-          do_mount_internal(dev_dentry, device_fs);
+          do_mount_internal(root_dentry, boot_root_fs);
+          graft_persistent_device_fs(device_fs);
         }
       }
     }
@@ -151,6 +150,21 @@ namespace kernel::filesystem
     m_mount_table.add_mount(new_mount);
   }
 
+  auto vfs::graft_persistent_device_fs(kstd::shared_ptr<devfs::filesystem> const & device_fs) -> void
+  {
+    if (auto new_root_dentry = resolve_path("/"))
+    {
+      auto dev_dentry = new_root_dentry->find_child("dev");
+      if (!dev_dentry)
+      {
+        dev_dentry = kstd::make_shared<dentry>(new_root_dentry, device_fs->root_inode(), "dev");
+        new_root_dentry->add_child(dev_dentry);
+      }
+
+      do_mount_internal(dev_dentry, device_fs);
+    }
+  }
+
   auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
   {
     if (!path::is_valid_absolute_path(path))
-- 
cgit v1.2.3


From d061f31f33feccb4203979c6e8d9bbaeabecb453 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Wed, 13 May 2026 10:13:13 +0200
Subject: refactor ext2 map_inode_block_index_to_global_block_number

---
 kernel/src/filesystem/vfs.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 535f898..f5d57be 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -143,7 +143,7 @@ namespace kernel::filesystem
     {
       parent_mount = m_mount_table.find_exact_mount(parent_mount_dentry->get_absolute_path().view());
     }
-    
+
     auto new_fs_root =
         kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
     auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
-- 
cgit v1.2.3


From 216ec44cf2fdc914ce38e3ab56eb3a8d82b54c77 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Thu, 14 May 2026 16:59:56 +0200
Subject: Refactor resolve_path

---
 kernel/src/filesystem/vfs.cpp | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index f5d57be..52ffcc8 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -20,6 +20,7 @@
 #include <optional>
 #include <ranges>
 #include <string_view>
+#include <utility>
 
 namespace
 {
@@ -165,11 +166,11 @@ namespace kernel::filesystem
     }
   }
 
-  auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
+  auto vfs::resolve_path_internal(std::string_view path) -> std::pair<kstd::shared_ptr<dentry>, kstd::shared_ptr<mount>>
   {
     if (!path::is_valid_absolute_path(path))
     {
-      return nullptr;
+      return {nullptr, nullptr};
     }
 
     auto current_mount = m_mount_table.find_exact_mount("/");
@@ -225,7 +226,7 @@ namespace kernel::filesystem
         auto found_inode = current_fs->lookup(current_dentry->get_inode(), part.view());
         if (!found_inode)
         {
-          return nullptr;
+          return {nullptr, nullptr};
         }
 
         next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part.view());
@@ -246,7 +247,7 @@ namespace kernel::filesystem
       {
         if (symlink_counter++ > constants::symloop_max)
         {
-          return nullptr;
+          return {nullptr, nullptr};
         }
 
         kstd::vector<uint8_t> buffer(constants::symlink_max_path_length);
@@ -269,9 +270,19 @@ namespace kernel::filesystem
 
       current_dentry = next_dentry;
     }
+    return {current_dentry, current_mount};
+  }
+
+  auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
+  {
+    return resolve_path_internal(path).first;
+  }
 
-    return current_dentry;
+  auto vfs::find_mount(std::string_view path) -> kstd::shared_ptr<mount>
+  {
+    return resolve_path_internal(path).second;
   }
+
 }  // namespace kernel::filesystem
 
 namespace kernel::tests::filesystem::vfs
-- 
cgit v1.2.3


From 146c40b22b834e4bf8d5e1d7256d3071f11d4bf9 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Thu, 14 May 2026 17:33:14 +0200
Subject: Rename mount_point_dentry to target_dentry

---
 kernel/src/filesystem/vfs.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 52ffcc8..31ffa42 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -53,9 +53,9 @@ namespace kernel::filesystem
     auto device_fs = kstd::make_shared<devfs::filesystem>();
     device_fs->mount(nullptr);
 
-    if (auto dev_mount_point_dentry = resolve_path("/dev"))
+    if (auto dev_target_dentry = resolve_path("/dev"))
     {
-      do_mount_internal(dev_mount_point_dentry, device_fs);
+      do_mount_internal(dev_target_dentry, device_fs);
     }
     else
     {
@@ -98,13 +98,13 @@ namespace kernel::filesystem
       return operation_result::invalid_path;
     }
 
-    if (auto mount_point_dentry = resolve_path(target))
+    if (auto target_dentry = resolve_path(target))
     {
       if (auto source_dentry = resolve_path(source))
       {
         if (auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode()))
         {
-          do_mount_internal(mount_point_dentry, fs);
+          do_mount_internal(target_dentry, fs);
           return operation_result::success;
         }
         return operation_result::invalid_filesystem;
@@ -135,10 +135,10 @@ namespace kernel::filesystem
     return operation_result::mount_point_not_found;
   }
 
-  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
-                              kstd::shared_ptr<filesystem> const & fs) -> void
+  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & target_dentry, kstd::shared_ptr<filesystem> const & fs)
+      -> void
   {
-    auto parent_mount_dentry = mount_point_dentry->find_mount_root_dentry();
+    auto parent_mount_dentry = target_dentry->find_mount_root_dentry();
     kstd::shared_ptr<mount> parent_mount = nullptr;
     if (parent_mount_dentry)
     {
@@ -146,8 +146,8 @@ namespace kernel::filesystem
     }
 
     auto new_fs_root =
-        kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
-    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
+        kstd::make_shared<dentry>(target_dentry->get_parent(), fs->root_inode(), target_dentry->get_name());
+    auto new_mount = kstd::make_shared<mount>(target_dentry, new_fs_root, fs, parent_mount);
     m_mount_table.add_mount(new_mount);
   }
 
-- 
cgit v1.2.3


From 4cc120e7dba5c858a3a0f68b63e91e8d7b831701 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Thu, 14 May 2026 18:03:44 +0200
Subject: Refactor do_mount_internal to use target_mount as parameter

---
 kernel/src/filesystem/vfs.cpp | 30 ++++++++++++++----------------
 1 file changed, 14 insertions(+), 16 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 31ffa42..c395e74 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -47,7 +47,8 @@ namespace kernel::filesystem
     root_fs->mount(nullptr);
 
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
-    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, nullptr));
+    auto root_mount = kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, nullptr);
+    m_mount_table.add_mount(root_mount);
 
     // mount devfs at /dev (inside rootfs, temporary, will be shadowed)
     auto device_fs = kstd::make_shared<devfs::filesystem>();
@@ -55,7 +56,7 @@ namespace kernel::filesystem
 
     if (auto dev_target_dentry = resolve_path("/dev"))
     {
-      do_mount_internal(dev_target_dentry, device_fs);
+      do_mount_internal(dev_target_dentry, root_mount, device_fs);
     }
     else
     {
@@ -69,7 +70,7 @@ namespace kernel::filesystem
       {
         if (auto root_dentry = resolve_path("/"))
         {
-          do_mount_internal(root_dentry, boot_root_fs);
+          do_mount_internal(root_dentry, root_mount, boot_root_fs);
           graft_persistent_device_fs(device_fs);
         }
       }
@@ -98,13 +99,15 @@ namespace kernel::filesystem
       return operation_result::invalid_path;
     }
 
-    if (auto target_dentry = resolve_path(target))
+    auto [target_dentry, target_mount] = resolve_path_internal(target);
+
+    if (target_dentry && target_mount)
     {
       if (auto source_dentry = resolve_path(source))
       {
         if (auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode()))
         {
-          do_mount_internal(target_dentry, fs);
+          do_mount_internal(target_dentry, target_mount, fs);
           return operation_result::success;
         }
         return operation_result::invalid_filesystem;
@@ -135,25 +138,20 @@ namespace kernel::filesystem
     return operation_result::mount_point_not_found;
   }
 
-  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & target_dentry, kstd::shared_ptr<filesystem> const & fs)
+  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & target_dentry,
+                              kstd::shared_ptr<mount> const & target_mount, kstd::shared_ptr<filesystem> const & fs)
       -> void
   {
-    auto parent_mount_dentry = target_dentry->find_mount_root_dentry();
-    kstd::shared_ptr<mount> parent_mount = nullptr;
-    if (parent_mount_dentry)
-    {
-      parent_mount = m_mount_table.find_exact_mount(parent_mount_dentry->get_absolute_path().view());
-    }
-
     auto new_fs_root =
         kstd::make_shared<dentry>(target_dentry->get_parent(), fs->root_inode(), target_dentry->get_name());
-    auto new_mount = kstd::make_shared<mount>(target_dentry, new_fs_root, fs, parent_mount);
+    auto new_mount = kstd::make_shared<mount>(target_dentry, new_fs_root, fs, target_mount);
     m_mount_table.add_mount(new_mount);
   }
 
   auto vfs::graft_persistent_device_fs(kstd::shared_ptr<devfs::filesystem> const & device_fs) -> void
   {
-    if (auto new_root_dentry = resolve_path("/"))
+    auto [new_root_dentry, root_mount] = resolve_path_internal("/");
+    if (new_root_dentry && root_mount)
     {
       auto dev_dentry = new_root_dentry->find_child("dev");
       if (!dev_dentry)
@@ -162,7 +160,7 @@ namespace kernel::filesystem
         new_root_dentry->add_child(dev_dentry);
       }
 
-      do_mount_internal(dev_dentry, device_fs);
+      do_mount_internal(dev_dentry, root_mount, device_fs);
     }
   }
 
-- 
cgit v1.2.3


From 963c926c68aac4606d80743aca8e7b052eee7efe Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Fri, 15 May 2026 11:42:33 +0200
Subject: Rename mount_table method from find_exact_mount to find_mount

---
 kernel/src/filesystem/vfs.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index c395e74..9b0440d 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -171,7 +171,7 @@ namespace kernel::filesystem
       return {nullptr, nullptr};
     }
 
-    auto current_mount = m_mount_table.find_exact_mount("/");
+    auto current_mount = m_mount_table.find_mount("/");
     if (!current_mount)
     {
       kapi::system::panic("[FILESYSTEM] no root mount found.");
@@ -232,7 +232,7 @@ namespace kernel::filesystem
       }
       else if (next_dentry->has_flag(dentry::dentry_flags::is_mount_point))
       {
-        current_mount = m_mount_table.find_exact_mount(next_dentry->get_absolute_path().view());
+        current_mount = m_mount_table.find_mount(next_dentry->get_absolute_path().view());
         if (!current_mount)
         {
           kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
@@ -260,7 +260,7 @@ namespace kernel::filesystem
 
         if (path::is_valid_absolute_path(symbolic_link_path))
         {
-          current_mount = m_mount_table.find_exact_mount("/");
+          current_mount = m_mount_table.find_mount("/");
           current_dentry = current_mount->get_root_dentry();
         }
         continue;
-- 
cgit v1.2.3


From 66d0e68376c9ad3e2b13f6ff8d999a0c85bda1a4 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 15 May 2026 15:47:06 +0200
Subject: renaming

---
 kernel/src/filesystem/vfs.cpp | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 9b0440d..77ae015 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -54,9 +54,9 @@ namespace kernel::filesystem
     auto device_fs = kstd::make_shared<devfs::filesystem>();
     device_fs->mount(nullptr);
 
-    if (auto dev_target_dentry = resolve_path("/dev"))
+    if (auto dev_mount_point_dentry = resolve_path("/dev"))
     {
-      do_mount_internal(dev_target_dentry, root_mount, device_fs);
+      do_mount_internal(dev_mount_point_dentry, root_mount, device_fs);
     }
     else
     {
@@ -99,15 +99,15 @@ namespace kernel::filesystem
       return operation_result::invalid_path;
     }
 
-    auto [target_dentry, target_mount] = resolve_path_internal(target);
+    auto [mount_point_dentry, mount_context] = resolve_path_internal(target);
 
-    if (target_dentry && target_mount)
+    if (mount_point_dentry && mount_context)
     {
       if (auto source_dentry = resolve_path(source))
       {
         if (auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode()))
         {
-          do_mount_internal(target_dentry, target_mount, fs);
+          do_mount_internal(mount_point_dentry, mount_context, fs);
           return operation_result::success;
         }
         return operation_result::invalid_filesystem;
@@ -138,26 +138,26 @@ namespace kernel::filesystem
     return operation_result::mount_point_not_found;
   }
 
-  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & target_dentry,
-                              kstd::shared_ptr<mount> const & target_mount, kstd::shared_ptr<filesystem> const & fs)
+  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
+                              kstd::shared_ptr<mount> const & parent_mount, kstd::shared_ptr<filesystem> const & fs)
       -> void
   {
     auto new_fs_root =
-        kstd::make_shared<dentry>(target_dentry->get_parent(), fs->root_inode(), target_dentry->get_name());
-    auto new_mount = kstd::make_shared<mount>(target_dentry, new_fs_root, fs, target_mount);
+        kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
+    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
     m_mount_table.add_mount(new_mount);
   }
 
   auto vfs::graft_persistent_device_fs(kstd::shared_ptr<devfs::filesystem> const & device_fs) -> void
   {
-    auto [new_root_dentry, root_mount] = resolve_path_internal("/");
-    if (new_root_dentry && root_mount)
+    auto [root_mount_point_dentry, root_mount] = resolve_path_internal("/");
+    if (root_mount_point_dentry && root_mount)
     {
-      auto dev_dentry = new_root_dentry->find_child("dev");
+      auto dev_dentry = root_mount_point_dentry->find_child("dev");
       if (!dev_dentry)
       {
-        dev_dentry = kstd::make_shared<dentry>(new_root_dentry, device_fs->root_inode(), "dev");
-        new_root_dentry->add_child(dev_dentry);
+        dev_dentry = kstd::make_shared<dentry>(root_mount_point_dentry, device_fs->root_inode(), "dev");
+        root_mount_point_dentry->add_child(dev_dentry);
       }
 
       do_mount_internal(dev_dentry, root_mount, device_fs);
-- 
cgit v1.2.3


From 1d647adb1ba20121eeb5c8e4470f48b2e972b3d4 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 15 May 2026 16:50:55 +0200
Subject: Mount can only be unmounted if no references are present, increment
 references on open file and decrement on close file

---
 kernel/src/filesystem/vfs.cpp | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 77ae015..3b3d6ff 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -89,7 +89,22 @@ namespace kernel::filesystem
 
   auto vfs::open(std::string_view path) -> kstd::shared_ptr<dentry>
   {
-    return resolve_path(path);
+    auto [dentry, mount] = resolve_path_internal(path);
+    mount->increment_ref_count();
+    return dentry;
+  }
+
+  auto vfs::close(kstd::shared_ptr<dentry> const & dentry) -> operation_result
+  {
+    if (auto mount = find_mount(dentry->get_absolute_path().view()))
+    {
+      if (mount->decrement_ref_count())
+      {
+        return operation_result::success;
+      }
+      return operation_result::close_failed;
+    }
+    return operation_result::invalid_path;
   }
 
   auto vfs::do_mount(std::string_view source, std::string_view target) -> operation_result
-- 
cgit v1.2.3


From 0e279db4e1b799c4db0cc7c714d57686e3de7089 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 15 May 2026 22:36:05 +0200
Subject: refactoring rootfs, no separate child management needed

---
 kernel/src/filesystem/vfs.cpp | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 3b3d6ff..67671e2 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -53,15 +53,7 @@ namespace kernel::filesystem
     // mount devfs at /dev (inside rootfs, temporary, will be shadowed)
     auto device_fs = kstd::make_shared<devfs::filesystem>();
     device_fs->mount(nullptr);
-
-    if (auto dev_mount_point_dentry = resolve_path("/dev"))
-    {
-      do_mount_internal(dev_mount_point_dentry, root_mount, device_fs);
-    }
-    else
-    {
-      kapi::system::panic("[FILESYSTEM] failed to resolve /dev for initial devfs mount.");
-    }
+    graft_persistent_device_fs(device_fs);
 
     // mount boot fs at / (shadows rootfs), re-graft devfs
     if (auto boot_device_dentry = resolve_path("/dev/ram0"))
-- 
cgit v1.2.3


From 1f9fe3cf18b561749cfbdb2db8ab7572ddc40c03 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 15 May 2026 22:38:24 +0200
Subject: uniform interface for open and close

---
 kernel/src/filesystem/vfs.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 67671e2..de19d38 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -86,9 +86,9 @@ namespace kernel::filesystem
     return dentry;
   }
 
-  auto vfs::close(kstd::shared_ptr<dentry> const & dentry) -> operation_result
+  auto vfs::close(std::string_view path) -> operation_result
   {
-    if (auto mount = find_mount(dentry->get_absolute_path().view()))
+    if (auto mount = find_mount(path))
     {
       if (mount->decrement_ref_count())
       {
-- 
cgit v1.2.3


From 2396fe6174ec875ba12dc135ab18f84550c07e9a Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Fri, 15 May 2026 22:40:52 +0200
Subject: avoid nullptr access

---
 kernel/src/filesystem/vfs.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index de19d38..f6eae25 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -82,6 +82,10 @@ namespace kernel::filesystem
   auto vfs::open(std::string_view path) -> kstd::shared_ptr<dentry>
   {
     auto [dentry, mount] = resolve_path_internal(path);
+    if (!dentry || !mount)
+    {
+      return nullptr;
+    }
     mount->increment_ref_count();
     return dentry;
   }
-- 
cgit v1.2.3


From efc7ba748b977a792188724c461852f01c111957 Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 16 May 2026 14:05:49 +0200
Subject: add vfs tests

---
 kernel/src/filesystem/vfs.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index f6eae25..8636d0f 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -140,13 +140,12 @@ namespace kernel::filesystem
     {
       return operation_result::success;
     }
-
-    if (remove_result == mount_table::operation_result::has_child_mounts)
+    else if (remove_result == mount_table::operation_result::mount_not_found)
     {
-      return operation_result::unmount_failed;
+      return operation_result::mount_point_not_found;
     }
 
-    return operation_result::mount_point_not_found;
+    return operation_result::unmount_failed;
   }
 
   auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
-- 
cgit v1.2.3


From 3b2f36d242eb895fd893ec7a674ff608f44f69ac Mon Sep 17 00:00:00 2001
From: Lukas Oesch <lukasoesch20@gmail.com>
Date: Sat, 16 May 2026 16:12:36 +0200
Subject: refactoring

---
 kernel/src/filesystem/vfs.cpp | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 8636d0f..bf9a77d 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -153,7 +153,7 @@ namespace kernel::filesystem
       -> void
   {
     auto new_fs_root =
-        kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
+        kstd::make_shared<dentry>(mount_point_dentry->parent(), fs->root_inode(), mount_point_dentry->name());
     auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
     m_mount_table.add_mount(new_mount);
   }
@@ -174,7 +174,8 @@ namespace kernel::filesystem
     }
   }
 
-  auto vfs::resolve_path_internal(std::string_view path) -> std::pair<kstd::shared_ptr<dentry>, kstd::shared_ptr<mount>>
+  auto vfs::resolve_path_internal(std::string_view path) const
+      -> std::pair<kstd::shared_ptr<dentry>, kstd::shared_ptr<mount>>
   {
     if (!path::is_valid_absolute_path(path))
     {
@@ -187,7 +188,7 @@ namespace kernel::filesystem
       kapi::system::panic("[FILESYSTEM] no root mount found.");
     }
 
-    auto current_dentry = current_mount->get_root_dentry();
+    auto current_dentry = current_mount->root_dentry();
 
     auto path_parts = path::split(path);
     kstd::vector path_parts_vector(path_parts.begin(), path_parts.end());
@@ -207,16 +208,16 @@ namespace kernel::filesystem
 
       if (part == "..")
       {
-        auto parent_dentry = current_dentry->get_parent();
+        auto parent_dentry = current_dentry->parent();
 
-        if (current_dentry == current_mount->get_root_dentry())
+        if (current_dentry == current_mount->root_dentry())
         {
-          if (current_mount->get_mount_path() == "/")
+          if (current_mount->mount_path() == "/")
           {
             continue;
           }
 
-          if (auto parent_mount = current_mount->get_parent_mount())
+          if (auto parent_mount = current_mount->parent_mount())
           {
             current_mount = parent_mount;
             current_dentry = parent_dentry;
@@ -242,13 +243,13 @@ namespace kernel::filesystem
       }
       else if (next_dentry->has_flag(dentry::dentry_flags::is_mount_point))
       {
-        current_mount = m_mount_table.find_mount(next_dentry->get_absolute_path().view());
+        current_mount = m_mount_table.find_mount(next_dentry->absolute_path().view());
         if (!current_mount)
         {
           kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
         }
 
-        next_dentry = current_mount->get_root_dentry();
+        next_dentry = current_mount->root_dentry();
       }
 
       if (next_dentry->get_inode()->is_symbolic_link())
@@ -271,7 +272,7 @@ namespace kernel::filesystem
         if (path::is_valid_absolute_path(symbolic_link_path))
         {
           current_mount = m_mount_table.find_mount("/");
-          current_dentry = current_mount->get_root_dentry();
+          current_dentry = current_mount->root_dentry();
         }
         continue;
       }
@@ -281,12 +282,12 @@ namespace kernel::filesystem
     return {current_dentry, current_mount};
   }
 
-  auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
+  auto vfs::resolve_path(std::string_view path) const -> kstd::shared_ptr<dentry>
   {
     return resolve_path_internal(path).first;
   }
 
-  auto vfs::find_mount(std::string_view path) -> kstd::shared_ptr<mount>
+  auto vfs::find_mount(std::string_view path) const -> kstd::shared_ptr<mount>
   {
     return resolve_path_internal(path).second;
   }
-- 
cgit v1.2.3


From 61d29a288334960cd9f43df91e4fd632a7f6ad66 Mon Sep 17 00:00:00 2001
From: Marcel Braun <marcel.braun@ost.ch>
Date: Mon, 25 May 2026 11:13:18 +0200
Subject: Increase reference count of source_mount when one of its files is
 mounted somewhere

---
 kernel/src/filesystem/vfs.cpp | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index bf9a77d..ae85291 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -47,7 +47,7 @@ namespace kernel::filesystem
     root_fs->mount(nullptr);
 
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
-    auto root_mount = kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, nullptr);
+    auto root_mount = kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, nullptr, nullptr);
     m_mount_table.add_mount(root_mount);
 
     // mount devfs at /dev (inside rootfs, temporary, will be shadowed)
@@ -56,13 +56,14 @@ namespace kernel::filesystem
     graft_persistent_device_fs(device_fs);
 
     // mount boot fs at / (shadows rootfs), re-graft devfs
-    if (auto boot_device_dentry = resolve_path("/dev/ram0"))
+    auto [boot_device_dentry, boot_device_mount_context] = resolve_path_internal("/dev/ram0");
+    if (boot_device_dentry && boot_device_mount_context)
     {
       if (auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device_dentry->get_inode()))
       {
         if (auto root_dentry = resolve_path("/"))
         {
-          do_mount_internal(root_dentry, root_mount, boot_root_fs);
+          do_mount_internal(root_dentry, root_mount, boot_root_fs, boot_device_mount_context);
           graft_persistent_device_fs(device_fs);
         }
       }
@@ -94,11 +95,8 @@ namespace kernel::filesystem
   {
     if (auto mount = find_mount(path))
     {
-      if (mount->decrement_ref_count())
-      {
-        return operation_result::success;
-      }
-      return operation_result::close_failed;
+      mount->decrement_ref_count();
+      return operation_result::success;
     }
     return operation_result::invalid_path;
   }
@@ -111,14 +109,14 @@ namespace kernel::filesystem
     }
 
     auto [mount_point_dentry, mount_context] = resolve_path_internal(target);
-
     if (mount_point_dentry && mount_context)
     {
-      if (auto source_dentry = resolve_path(source))
+      auto [source_dentry, source_mount_context] = resolve_path_internal(source);
+      if (source_dentry && source_mount_context)
       {
         if (auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode()))
         {
-          do_mount_internal(mount_point_dentry, mount_context, fs);
+          do_mount_internal(mount_point_dentry, mount_context, fs, source_mount_context);
           return operation_result::success;
         }
         return operation_result::invalid_filesystem;
@@ -149,12 +147,12 @@ namespace kernel::filesystem
   }
 
   auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
-                              kstd::shared_ptr<mount> const & parent_mount, kstd::shared_ptr<filesystem> const & fs)
-      -> void
+                              kstd::shared_ptr<mount> const & parent_mount, kstd::shared_ptr<filesystem> const & fs,
+                              kstd::shared_ptr<mount> const & source_mount) -> void
   {
     auto new_fs_root =
         kstd::make_shared<dentry>(mount_point_dentry->parent(), fs->root_inode(), mount_point_dentry->name());
-    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
+    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount, source_mount);
     m_mount_table.add_mount(new_mount);
   }
 
-- 
cgit v1.2.3


From dc9bd3b44cbbd0235a176f05c27eb15ff31f5e09 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Fri, 22 May 2026 20:18:05 +0200
Subject: kernel/vfs: prepare fs type registration support

---
 kernel/src/filesystem/vfs.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index ae85291..d22c74b 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -8,10 +8,12 @@
 #include <kernel/filesystem/mount_table.hpp>
 #include <kernel/filesystem/path.hpp>
 #include <kernel/filesystem/rootfs/filesystem.hpp>
+#include <kernel/filesystem/type.hpp>
 
 #include <kapi/system.hpp>
 
 #include <kstd/memory>
+#include <kstd/print>
 #include <kstd/string>
 #include <kstd/vector>
 
@@ -19,9 +21,16 @@
 #include <cstdint>
 #include <optional>
 #include <ranges>
+#include <span>
 #include <string_view>
 #include <utility>
 
+extern "C"
+{
+  extern kernel::filesystem::type const * const __vfs_type_descriptors_begin;
+  extern kernel::filesystem::type const * const __vfs_type_descriptors_end;
+}
+
 namespace
 {
   constinit auto static active_vfs = std::optional<kernel::filesystem::vfs>{};
@@ -42,6 +51,12 @@ namespace kernel::filesystem
 
   auto vfs::init_internal() -> void
   {
+    auto type_descriptors = std::span{&__vfs_type_descriptors_begin, &__vfs_type_descriptors_end} |
+                            std::views::filter([](auto p) { return p != nullptr; });
+    std::ranges::for_each(type_descriptors, [](auto descriptor) {
+      kstd::println("[OS] registering filesystem '{}'", descriptor->name());
+    });
+
     // mount rootfs at /
     auto root_fs = kstd::make_shared<rootfs::filesystem>();
     root_fs->mount(nullptr);
-- 
cgit v1.2.3


From 86170be29f6cb72b29865db0975de09bec89f854 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Mon, 1 Jun 2026 10:40:39 +0200
Subject: kernel/vfs: rename type descriptor section

---
 kernel/src/filesystem/vfs.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index d22c74b..c297210 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -27,8 +27,8 @@
 
 extern "C"
 {
-  extern kernel::filesystem::type const * const __vfs_type_descriptors_begin;
-  extern kernel::filesystem::type const * const __vfs_type_descriptors_end;
+  extern kernel::filesystem::type const * const __start_vfs_type_descriptors;
+  extern kernel::filesystem::type const * const __stop_vfs_type_descriptors;
 }
 
 namespace
@@ -51,7 +51,7 @@ namespace kernel::filesystem
 
   auto vfs::init_internal() -> void
   {
-    auto type_descriptors = std::span{&__vfs_type_descriptors_begin, &__vfs_type_descriptors_end} |
+    auto type_descriptors = std::span{&__start_vfs_type_descriptors, &__stop_vfs_type_descriptors} |
                             std::views::filter([](auto p) { return p != nullptr; });
     std::ranges::for_each(type_descriptors, [](auto descriptor) {
       kstd::println("[OS] registering filesystem '{}'", descriptor->name());
-- 
cgit v1.2.3


From 568e9586c036fc319fc36b12495e5deacb167be9 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Mon, 1 Jun 2026 20:10:57 +0200
Subject: kernel/vfs: simplify initialization

---
 kernel/src/filesystem/vfs.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index c297210..91afc13 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -45,12 +45,12 @@ namespace kernel::filesystem
       kapi::system::panic("[FILESYSTEM] vfs has already been initialized.");
     }
 
-    active_vfs.emplace(vfs{});
-    active_vfs->init_internal();
+    active_vfs.emplace();
   }
 
-  auto vfs::init_internal() -> void
+  vfs::vfs()
   {
+    // Register all compiled-in filesystems
     auto type_descriptors = std::span{&__start_vfs_type_descriptors, &__stop_vfs_type_descriptors} |
                             std::views::filter([](auto p) { return p != nullptr; });
     std::ranges::for_each(type_descriptors, [](auto descriptor) {
-- 
cgit v1.2.3


From 6c8b068c15e28e91117f84cb8d5789f5fe6fcbd0 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Mon, 1 Jun 2026 20:31:57 +0200
Subject: kstd/string: simplify comparisons

---
 kernel/src/filesystem/vfs.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 91afc13..b0d63a2 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -241,22 +241,22 @@ namespace kernel::filesystem
         continue;
       }
 
-      auto next_dentry = current_dentry->find_child(part.view());
+      auto next_dentry = current_dentry->find_child(part);
       if (!next_dentry)
       {
         auto current_fs = current_mount->get_filesystem();
-        auto found_inode = current_fs->lookup(current_dentry->get_inode(), part.view());
+        auto found_inode = current_fs->lookup(current_dentry->get_inode(), part);
         if (!found_inode)
         {
           return {nullptr, nullptr};
         }
 
-        next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part.view());
+        next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part);
         current_dentry->add_child(next_dentry);
       }
       else if (next_dentry->has_flag(dentry::dentry_flags::is_mount_point))
       {
-        current_mount = m_mount_table.find_mount(next_dentry->absolute_path().view());
+        current_mount = m_mount_table.find_mount(next_dentry->absolute_path());
         if (!current_mount)
         {
           kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
-- 
cgit v1.2.3


From ad2319188269331f4873adbeb44380d63e8e83c5 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Mon, 1 Jun 2026 21:15:25 +0200
Subject: kernel/vfs: manage filesystem registrations

---
 kernel/src/filesystem/vfs.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index b0d63a2..8dcae2c 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -53,8 +53,9 @@ namespace kernel::filesystem
     // Register all compiled-in filesystems
     auto type_descriptors = std::span{&__start_vfs_type_descriptors, &__stop_vfs_type_descriptors} |
                             std::views::filter([](auto p) { return p != nullptr; });
-    std::ranges::for_each(type_descriptors, [](auto descriptor) {
-      kstd::println("[OS] registering filesystem '{}'", descriptor->name());
+    std::ranges::for_each(type_descriptors, [this](auto descriptor) {
+      kstd::println("[FILESYSTEM] registering '{}'", descriptor->name());
+      m_filesystems.emplace(descriptor->name(), descriptor);
     });
 
     // mount rootfs at /
-- 
cgit v1.2.3


From d2d4fa3330a09f421b8658c077166cc493532b9e Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Tue, 2 Jun 2026 10:54:17 +0200
Subject: kernel/vfs: extract fs type registry

---
 kernel/src/filesystem/vfs.cpp | 17 -----------------
 1 file changed, 17 deletions(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 8dcae2c..8d1fd23 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -8,29 +8,20 @@
 #include <kernel/filesystem/mount_table.hpp>
 #include <kernel/filesystem/path.hpp>
 #include <kernel/filesystem/rootfs/filesystem.hpp>
-#include <kernel/filesystem/type.hpp>
 
 #include <kapi/system.hpp>
 
 #include <kstd/memory>
 #include <kstd/print>
-#include <kstd/string>
 #include <kstd/vector>
 
 #include <algorithm>
 #include <cstdint>
 #include <optional>
 #include <ranges>
-#include <span>
 #include <string_view>
 #include <utility>
 
-extern "C"
-{
-  extern kernel::filesystem::type const * const __start_vfs_type_descriptors;
-  extern kernel::filesystem::type const * const __stop_vfs_type_descriptors;
-}
-
 namespace
 {
   constinit auto static active_vfs = std::optional<kernel::filesystem::vfs>{};
@@ -50,14 +41,6 @@ namespace kernel::filesystem
 
   vfs::vfs()
   {
-    // Register all compiled-in filesystems
-    auto type_descriptors = std::span{&__start_vfs_type_descriptors, &__stop_vfs_type_descriptors} |
-                            std::views::filter([](auto p) { return p != nullptr; });
-    std::ranges::for_each(type_descriptors, [this](auto descriptor) {
-      kstd::println("[FILESYSTEM] registering '{}'", descriptor->name());
-      m_filesystems.emplace(descriptor->name(), descriptor);
-    });
-
     // mount rootfs at /
     auto root_fs = kstd::make_shared<rootfs::filesystem>();
     root_fs->mount(nullptr);
-- 
cgit v1.2.3


From 772861fc5fae1c126fcc63a8809b0a9c729bd152 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Tue, 2 Jun 2026 13:43:49 +0200
Subject: kernel/vfs: add type registry tests

---
 kernel/src/filesystem/vfs.cpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'kernel/src/filesystem/vfs.cpp')

diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 8d1fd23..e5dff8c 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -12,7 +12,6 @@
 #include <kapi/system.hpp>
 
 #include <kstd/memory>
-#include <kstd/print>
 #include <kstd/vector>
 
 #include <algorithm>
-- 
cgit v1.2.3