7 files changed, 99 insertions, 156 deletions

diff --git a/kernel/src/filesystem/dentry.cpp b/kernel/src/filesystem/dentry.cpp
index a77ce23..c21771b 100644
--- a/kernel/src/filesystem/dentry.cpp
+++ b/kernel/src/filesystem/dentry.cpp
@@ -66,6 +66,16 @@ namespace kernel::filesystem
     return path;
   }
 
+  auto dentry::find_mount_root_dentry() const -> kstd::shared_ptr<dentry>
+  {
+    auto parent = m_parent;
+    while (parent && !parent->has_flag(dentry_flags::is_mount_root))
+    {
+      parent = parent->get_parent();
+    }
+    return parent;
+  }
+
   auto dentry::add_child(kstd::shared_ptr<dentry> const & child) -> void
   {
     m_children.push_back(child);
diff --git a/kernel/src/filesystem/dentry.tests.cpp b/kernel/src/filesystem/dentry.tests.cpp
index dd01394..e9ecbc8 100644
--- a/kernel/src/filesystem/dentry.tests.cpp
+++ b/kernel/src/filesystem/dentry.tests.cpp
@@ -28,7 +28,7 @@ SCENARIO("Dentry construction", "[filesystem][dentry]")
 
       THEN("no flag is set")
       {
-        REQUIRE_FALSE(child_dentry.has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
+        REQUIRE_FALSE(child_dentry.has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
       }
     }
 
@@ -53,7 +53,7 @@ SCENARIO("Dentry construction", "[filesystem][dentry]")
 
       THEN("no flag is set")
       {
-        REQUIRE_FALSE(child_dentry.has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
+        REQUIRE_FALSE(child_dentry.has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
       }
     }
 
@@ -104,22 +104,22 @@ SCENARIO("Dentry Flag logic", "[filesystem][dentry]")
 
     WHEN("setting a flag")
     {
-      dentry.set_flag(kernel::filesystem::dentry::dentry_flags::mounted);
+      dentry.set_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point);
 
       THEN("the flag is set")
       {
-        REQUIRE(dentry.has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
+        REQUIRE(dentry.has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
       }
     }
 
     WHEN("unsetting a flag")
     {
-      dentry.set_flag(kernel::filesystem::dentry::dentry_flags::mounted);
-      dentry.unset_flag(kernel::filesystem::dentry::dentry_flags::mounted);
+      dentry.set_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point);
+      dentry.unset_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point);
 
       THEN("the flag is unset")
       {
-        REQUIRE_FALSE(dentry.has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
+        REQUIRE_FALSE(dentry.has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
       }
     }
   }
diff --git a/kernel/src/filesystem/mount.cpp b/kernel/src/filesystem/mount.cpp
index 67450b7..749c86a 100644
--- a/kernel/src/filesystem/mount.cpp
+++ b/kernel/src/filesystem/mount.cpp
@@ -13,10 +13,8 @@
 namespace kernel::filesystem
 {
   mount::mount(kstd::shared_ptr<dentry> const & mount_dentry, kstd::shared_ptr<dentry> const & root_dentry,
-               kstd::shared_ptr<filesystem> const & fs, std::string_view mount_path,
-               kstd::shared_ptr<mount> const & parent_mount)
-      : m_mount_path(mount_path)
-      , m_mount_dentry(mount_dentry)
+               kstd::shared_ptr<filesystem> const & fs, kstd::shared_ptr<mount> const & parent_mount)
+      : m_mount_dentry(mount_dentry)
       , m_root_dentry(root_dentry)
       , m_filesystem(fs)
       , m_parent_mount(parent_mount)
@@ -37,14 +35,18 @@ namespace kernel::filesystem
     return m_filesystem;
   }
 
-  auto mount::root_dentry() const -> kstd::shared_ptr<dentry> const &
+  auto mount::get_root_dentry() const -> kstd::shared_ptr<dentry> const &
   {
     return m_root_dentry;
   }
 
-  auto mount::get_mount_path() const -> std::string_view
+  auto mount::get_mount_path() const -> kstd::string
   {
-    return m_mount_path.view();
+    if (m_mount_dentry)
+    {
+      return m_mount_dentry->get_absolute_path();
+    }
+    return "/";
   }
 
   auto mount::get_parent_mount() const -> kstd::shared_ptr<mount> const &
diff --git a/kernel/src/filesystem/mount.tests.cpp b/kernel/src/filesystem/mount.tests.cpp
index d630464..58e9bab 100644
--- a/kernel/src/filesystem/mount.tests.cpp
+++ b/kernel/src/filesystem/mount.tests.cpp
@@ -21,12 +21,12 @@ SCENARIO("Mount construction", "[filesystem][mount]")
 
     WHEN("constructing a mount with the filesystem and root dentry")
     {
-      auto mount = kernel::filesystem::mount{root_dentry, root_dentry, fs, "/", nullptr};
+      auto mount = kernel::filesystem::mount{root_dentry, root_dentry, fs, nullptr};
 
       THEN("the mount has the correct filesystem, root dentry, mount dentry, and mount path")
       {
         REQUIRE(mount.get_filesystem() == fs);
-        REQUIRE(mount.root_dentry() == root_dentry);
+        REQUIRE(mount.get_root_dentry() == root_dentry);
         REQUIRE(mount.get_mount_dentry() == root_dentry);
         REQUIRE(mount.get_mount_path() == "/");
       }
@@ -41,7 +41,7 @@ SCENARIO("Mount construction", "[filesystem][mount]")
     {
       THEN("the constructor panics")
       {
-        REQUIRE_THROWS_AS((kernel::filesystem::mount{root_dentry, root_dentry, nullptr, "/", nullptr}),
+        REQUIRE_THROWS_AS((kernel::filesystem::mount{root_dentry, root_dentry, nullptr, nullptr}),
                           kernel::tests::cpu::halt);
       }
     }
diff --git a/kernel/src/filesystem/mount_table.cpp b/kernel/src/filesystem/mount_table.cpp
index 965e83b..daef93e 100644
--- a/kernel/src/filesystem/mount_table.cpp
+++ b/kernel/src/filesystem/mount_table.cpp
@@ -7,42 +7,11 @@
 #include <kstd/vector>
 
 #include <algorithm>
-#include <cstddef>
 #include <ranges>
 #include <string_view>
 
 namespace kernel::filesystem
 {
-  namespace
-  {
-    auto is_descendant_of(kstd::shared_ptr<mount> const & candidate, kstd::shared_ptr<mount> const & ancestor) -> bool
-    {
-      for (auto current = candidate; current; current = current->get_parent_mount())
-      {
-        if (current == ancestor)
-        {
-          return true;
-        }
-      }
-
-      return false;
-    }
-
-    auto is_strict_prefix(std::string_view prefix, std::string_view path) -> bool
-    {
-      return prefix != "/" && path.starts_with(prefix) && path.size() > prefix.size() && path[prefix.size()] == '/';
-    }
-
-    auto is_visible_mount(kstd::shared_ptr<mount> const & candidate,
-                          kstd::vector<kstd::shared_ptr<mount>> const & mounts) -> bool
-    {
-      return std::ranges::none_of(mounts, [&](auto const & other) {
-        return other != candidate && is_strict_prefix(other->get_mount_path(), candidate->get_mount_path()) &&
-               !is_descendant_of(candidate, other);
-      });
-    }
-  }  // namespace
-
   auto mount_table::has_child_mounts(kstd::shared_ptr<mount> const & parent_mount) const -> bool
   {
     return std::ranges::any_of(
@@ -52,19 +21,24 @@ namespace kernel::filesystem
   void mount_table::add_mount(kstd::shared_ptr<mount> const & mount)
   {
     m_mounts.push_back(mount);
+
     if (auto mount_dentry = mount->get_mount_dentry())
     {
-      mount_dentry->set_flag(dentry::dentry_flags::mounted);
+      mount_dentry->set_flag(dentry::dentry_flags::is_mount_point);
+    }
+    if (auto root_dentry = mount->get_root_dentry())
+    {
+      root_dentry->set_flag(dentry::dentry_flags::is_mount_root);
     }
   }
 
   auto mount_table::remove_mount(std::string_view path) -> operation_result
   {
-    auto mount_it = std::ranges::find_if(std::ranges::reverse_view(m_mounts), [&](auto const & mount) {
-      return mount->get_mount_path() == path && is_visible_mount(mount, m_mounts);
-    });
+    auto mount_range =
+        std::ranges::find_last_if(m_mounts, [&](auto const & mount) { return mount->get_mount_path() == path; });
+    auto mount_it = mount_range.begin();
 
-    if (mount_it == std::ranges::reverse_view(m_mounts).end())
+    if (mount_it == m_mounts.end())
     {
       return operation_result::mount_not_found;
     }
@@ -75,39 +49,16 @@ namespace kernel::filesystem
       return operation_result::has_child_mounts;
     }
 
-    mount->get_mount_dentry()->unset_flag(dentry::dentry_flags::mounted);
-    m_mounts.erase(std::ranges::find(m_mounts, mount));
+    mount->get_mount_dentry()->unset_flag(dentry::dentry_flags::is_mount_point);
+    m_mounts.erase(mount_it);
     return operation_result::removed;
   }
 
-  auto mount_table::find_longest_prefix_mount(std::string_view path) const -> kstd::shared_ptr<mount>
-  {
-    kstd::shared_ptr<mount> mount_with_longest_prefix = nullptr;
-    std::size_t best_len = 0;
-
-    for (auto const & mount : m_mounts)
-    {
-      auto mp = mount->get_mount_path();
-
-      // /a/b/c should match /a/b but not /a/bb or /a/b/c/d, / should match everything
-      bool is_prefix = path.starts_with(mp) && (mp == "/" || path.size() == mp.size() || path[mp.size()] == '/');
-      bool visible = is_visible_mount(mount, m_mounts);
-
-      if (is_prefix && visible && mp.size() >= best_len)
-      {
-        mount_with_longest_prefix = mount;
-        best_len = mp.size();
-      }
-    }
-
-    return mount_with_longest_prefix;
-  }
-
   auto mount_table::find_exact_mount(std::string_view path) const -> kstd::shared_ptr<mount>
   {
-    auto reversed_mounts = std::ranges::reverse_view(m_mounts);
-    auto mount_it =
-        std::ranges::find_if(reversed_mounts, [&](auto const & mount) { return mount->get_mount_path() == path; });
-    return (mount_it != reversed_mounts.end()) ? *mount_it : nullptr;
+    auto mount_range =
+        std::ranges::find_last_if(m_mounts, [&](auto const & mount) { return mount->get_mount_path() == path; });
+    auto mount_it = mount_range.begin();
+    return (mount_it != m_mounts.end()) ? *mount_it : nullptr;
   }
 }  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/mount_table.tests.cpp b/kernel/src/filesystem/mount_table.tests.cpp
index efacdfe..4ae8711 100644
--- a/kernel/src/filesystem/mount_table.tests.cpp
+++ b/kernel/src/filesystem/mount_table.tests.cpp
@@ -19,12 +19,6 @@ SCENARIO("Mount table construction", "[filesystem][mount_table]")
   {
     kernel::filesystem::mount_table table;
 
-    THEN("finding any mount returns null")
-    {
-      REQUIRE(table.find_longest_prefix_mount("/") == nullptr);
-      REQUIRE(table.find_longest_prefix_mount("/any/path") == nullptr);
-    }
-
     THEN("removing any mount returns mount_not_found")
     {
       REQUIRE(table.remove_mount("/") == kernel::filesystem::mount_table::operation_result::mount_not_found);
@@ -40,31 +34,26 @@ SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem]
     kernel::filesystem::mount_table table;
 
     auto fs1 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode1 = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode1, "/");
-    auto mount1 = kstd::make_shared<kernel::filesystem::mount>(root_dentry1, root_dentry1, fs1, "/", nullptr);
+    auto root_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount1 = kstd::make_shared<kernel::filesystem::mount>(mount_dentry1, root_dentry1, fs1, nullptr);
 
     auto fs2 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode2 = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode2, "/");
-    auto mount2 = kstd::make_shared<kernel::filesystem::mount>(root_dentry1, root_dentry2, fs2, "/mnt", nullptr);
+    auto root_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/mnt");
+    auto mount2 = kstd::make_shared<kernel::filesystem::mount>(mount_dentry2, root_dentry2, fs2, nullptr);
 
     table.add_mount(mount1);
     table.add_mount(mount2);
 
     THEN("dentry flags are set correctly for mounted dentries")
     {
-      REQUIRE(root_dentry1->has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
-      REQUIRE_FALSE(root_dentry2->has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
-    }
-
-    THEN("finding mounts by longest prefix returns the correct mount")
-    {
-      REQUIRE(table.find_longest_prefix_mount("/") == mount1);
-      REQUIRE(table.find_longest_prefix_mount("/file") == mount1);
-      REQUIRE(table.find_longest_prefix_mount("/mnt") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/mnt/file") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/other") == mount1);
+      REQUIRE(mount_dentry1->has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
+      REQUIRE(mount_dentry2->has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
     }
 
     THEN("finding mounts by exact valid path returns the correct mount")
@@ -82,8 +71,7 @@ SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem]
     THEN("removing a mount that has no child mounts succeeds")
     {
       REQUIRE(table.remove_mount("/mnt") == kernel::filesystem::mount_table::operation_result::removed);
-      REQUIRE_FALSE(root_dentry2->has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
-      REQUIRE(table.find_longest_prefix_mount("/mnt") == mount1);
+      REQUIRE_FALSE(root_dentry2->has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
     }
 
     THEN("removing a mount that does not exist returns mount_not_found")
@@ -97,27 +85,22 @@ SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem]
     kernel::filesystem::mount_table table;
 
     auto fs1 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode1 = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode1, "/");
-    auto mount1 = kstd::make_shared<kernel::filesystem::mount>(root_dentry1, root_dentry1, fs1, "/", nullptr);
+    auto root_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount1 = kstd::make_shared<kernel::filesystem::mount>(mount_dentry1, root_dentry1, fs1, nullptr);
 
     auto fs2 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode2 = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode2, "/");
-    auto mount2 = kstd::make_shared<kernel::filesystem::mount>(root_dentry1, root_dentry2, fs2, "/", mount1);
+    auto root_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount2 = kstd::make_shared<kernel::filesystem::mount>(mount_dentry2, root_dentry2, fs2, nullptr);
 
     table.add_mount(mount1);
     table.add_mount(mount2);
 
-    THEN("finding mounts by longest prefix returns the correct mount")
-    {
-      REQUIRE(table.find_longest_prefix_mount("/") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/file") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/mnt") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/mnt/file") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/other") == mount2);
-    }
-
     THEN("finding mounts by exact valid path returns the correct mount")
     {
       REQUIRE(table.find_exact_mount("/") == mount2);
@@ -126,8 +109,7 @@ SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem]
     THEN("removing the topmost mount with the same path succeeds")
     {
       REQUIRE(table.remove_mount("/") == kernel::filesystem::mount_table::operation_result::removed);
-      REQUIRE_FALSE(root_dentry2->has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
-      REQUIRE(table.find_longest_prefix_mount("/") == mount1);
+      REQUIRE_FALSE(root_dentry2->has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
     }
   }
 
@@ -136,34 +118,30 @@ SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem]
     kernel::filesystem::mount_table table;
 
     auto fs1 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode1 = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode1, "/");
-    auto mount1 = kstd::make_shared<kernel::filesystem::mount>(root_dentry1, root_dentry1, fs1, "/", nullptr);
+    auto root_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount_dentry1 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount1 = kstd::make_shared<kernel::filesystem::mount>(mount_dentry1, root_dentry1, fs1, nullptr);
 
     auto fs2 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode2 = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode2, "/");
-    auto mount2 = kstd::make_shared<kernel::filesystem::mount>(root_dentry1, root_dentry2, fs2, "/mnt", mount1);
+    auto root_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount_dentry2 = kstd::make_shared<kernel::filesystem::dentry>(
+        mount_dentry1, kstd::make_shared<kernel::tests::filesystem::inode>(), "mnt");
+    auto mount2 = kstd::make_shared<kernel::filesystem::mount>(mount_dentry2, root_dentry2, fs2, mount1);
 
     auto fs3 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode3 = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry3 = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode3, "/");
-    auto mount3 = kstd::make_shared<kernel::filesystem::mount>(root_dentry2, root_dentry3, fs3, "/mnt/submnt", mount2);
+    auto root_dentry3 = kstd::make_shared<kernel::filesystem::dentry>(
+        nullptr, kstd::make_shared<kernel::tests::filesystem::inode>(), "/");
+    auto mount_dentry3 = kstd::make_shared<kernel::filesystem::dentry>(
+        mount_dentry2, kstd::make_shared<kernel::tests::filesystem::inode>(), "submnt");
+    auto mount3 = kstd::make_shared<kernel::filesystem::mount>(mount_dentry3, root_dentry3, fs3, mount2);
 
     table.add_mount(mount1);
     table.add_mount(mount2);
     table.add_mount(mount3);
 
-    THEN("finding mounts by path returns the correct mount based on longest prefix")
-    {
-      REQUIRE(table.find_longest_prefix_mount("/") == mount1);
-      REQUIRE(table.find_longest_prefix_mount("/file") == mount1);
-      REQUIRE(table.find_longest_prefix_mount("/mnt") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/mnt/file") == mount2);
-      REQUIRE(table.find_longest_prefix_mount("/mnt/submnt") == mount3);
-      REQUIRE(table.find_longest_prefix_mount("/other") == mount1);
-    }
-
     THEN("removing a mount with child mounts returns has_child_mounts")
     {
       REQUIRE(table.remove_mount("/") == kernel::filesystem::mount_table::operation_result::has_child_mounts);
@@ -173,8 +151,7 @@ SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem]
     THEN("removing a leaf mount succeeds")
     {
       REQUIRE(table.remove_mount("/mnt/submnt") == kernel::filesystem::mount_table::operation_result::removed);
-      REQUIRE_FALSE(root_dentry3->has_flag(kernel::filesystem::dentry::dentry_flags::mounted));
-      REQUIRE(table.find_longest_prefix_mount("/mnt/submnt") == mount2);
+      REQUIRE_FALSE(root_dentry3->has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
     }
   }
 }
diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 1410b2a..ee7c262 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>();
@@ -138,13 +138,16 @@ 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->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>(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);
   }
 
@@ -161,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());
@@ -183,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() == "/")
           {
@@ -214,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)
@@ -222,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())
@@ -245,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;
       }