117 files changed, 1718 insertions, 1719 deletions

diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
index c44383b8..359ad1f6 100644
--- a/kernel/CMakeLists.txt
+++ b/kernel/CMakeLists.txt
@@ -56,38 +56,38 @@ target_sources("kernel_lib" PRIVATE
     "kernel/drivers/pseudo/zero.cpp"
     "kernel/drivers/storage/ram_disk.cpp"
 
-    # Filesystem Subsystem
-    "kernel/filesystem/byte_offset_file_descriptor.cpp"
-    "kernel/filesystem/dentry.cpp"
-    "kernel/filesystem/device_inode.cpp"
-    "kernel/filesystem/device_number_registry.cpp"
-    "kernel/filesystem/directory_file_descriptor.cpp"
-    "kernel/filesystem/driver_registry.cpp"
-    "kernel/filesystem/error.cpp"
-    "kernel/filesystem/inode.cpp"
-    "kernel/filesystem/mount_table.cpp"
-    "kernel/filesystem/mount.cpp"
-    "kernel/filesystem/open_file_descriptor.cpp"
-    "kernel/filesystem/open_file_table.cpp"
-    "kernel/filesystem/vfs.cpp"
+    # Virtual Filesystem Subsystem
+    "kernel/vfs/byte_offset_file_descriptor.cpp"
+    "kernel/vfs/dentry.cpp"
+    "kernel/vfs/device_inode.cpp"
+    "kernel/vfs/device_number_registry.cpp"
+    "kernel/vfs/directory_file_descriptor.cpp"
+    "kernel/vfs/driver_registry.cpp"
+    "kernel/vfs/error.cpp"
+    "kernel/vfs/inode.cpp"
+    "kernel/vfs/mount_table.cpp"
+    "kernel/vfs/mount.cpp"
+    "kernel/vfs/open_file_descriptor.cpp"
+    "kernel/vfs/open_file_table.cpp"
+    "kernel/vfs.cpp"
 
     # DevFS Filesystem
-    "kernel/filesystem/devfs/filesystem.cpp"
-    "kernel/filesystem/devfs/inode.cpp"
-    "kernel/filesystem/devfs/module.cpp"
+    "kernel/filesystems/devfs/filesystem.cpp"
+    "kernel/filesystems/devfs/inode.cpp"
+    "kernel/filesystems/devfs/module.cpp"
 
     # ext2 Filesystem
-    "kernel/filesystem/ext2/directory_iterator.cpp"
-    "kernel/filesystem/ext2/error.cpp"
-    "kernel/filesystem/ext2/filesystem.cpp"
-    "kernel/filesystem/ext2/inode.cpp"
-    "kernel/filesystem/ext2/module.cpp"
-    "kernel/filesystem/ext2/write_batch.cpp"
+    "kernel/filesystems/ext2/directory_iterator.cpp"
+    "kernel/filesystems/ext2/error.cpp"
+    "kernel/filesystems/ext2/filesystem.cpp"
+    "kernel/filesystems/ext2/inode.cpp"
+    "kernel/filesystems/ext2/module.cpp"
+    "kernel/filesystems/ext2/write_batch.cpp"
 
     # Rootfs Filesystem
-    "kernel/filesystem/rootfs/filesystem.cpp"
-    "kernel/filesystem/rootfs/inode.cpp"
-    "kernel/filesystem/rootfs/module.cpp"
+    "kernel/filesystems/rootfs/filesystem.cpp"
+    "kernel/filesystems/rootfs/inode.cpp"
+    "kernel/filesystems/rootfs/module.cpp"
 )
 
 file(GLOB_RECURSE KERNEL_HEADERS
@@ -184,7 +184,7 @@ if(BUILD_TESTING)
     )
 
     target_compile_definitions("${TEST_TARGET}" PRIVATE
-        KERNEL_TEST_ASSETS_DIR="${CMAKE_CURRENT_SOURCE_DIR}/kernel/test_support/filesystem/test_assets"
+        KERNEL_TEST_ASSETS_DIR="${CMAKE_CURRENT_SOURCE_DIR}/kernel/test_support/vfs/test_assets"
     )
     
     if(COMMAND "enable_coverage" AND TEACHOS_ENABLE_TEST_COVERAGE)
diff --git a/kernel/kapi/filesystem.cpp b/kernel/kapi/filesystem.cpp
index e4b3443a..e50ce2c0 100644
--- a/kernel/kapi/filesystem.cpp
+++ b/kernel/kapi/filesystem.cpp
@@ -1,10 +1,6 @@
 #include <kapi/filesystem.hpp>
 
-#include <kernel/filesystem/byte_offset_file_descriptor.hpp>
-#include <kernel/filesystem/directory_file_descriptor.hpp>
-#include <kernel/filesystem/open_file_descriptor.hpp>
-#include <kernel/filesystem/open_file_table.hpp>
-#include <kernel/filesystem/vfs.hpp>
+#include <kernel/vfs.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/result.hpp>
@@ -20,77 +16,76 @@ namespace kapi::filesystem
 {
   auto mount(std::string_view source, std::string_view target) -> kstd::result<void>
   {
-    return kernel::filesystem::vfs::get().mount(source, target);
+    return kernel::vfs::vfs::get().mount(source, target);
   }
 
   auto umount(std::string_view target) -> kstd::result<void>
   {
-    return kernel::filesystem::vfs::get().unmount(target);
+    return kernel::vfs::vfs::get().unmount(target);
   }
 
   auto open(std::string_view path) -> kstd::result<std::size_t>
   {
-    return kernel::filesystem::vfs::get()
+    return kernel::vfs::vfs::get()
         .open(path)
-        .transform([](auto dentry) -> kstd::shared_ptr<kernel::filesystem::open_file_descriptor> {
+        .transform([](auto dentry) -> kstd::shared_ptr<kernel::vfs::open_file_descriptor> {
           if (dentry->inode()->is_directory())
           {
-            return kstd::make_shared<kernel::filesystem::directory_file_descriptor>(dentry);
+            return kstd::make_shared<kernel::vfs::directory_file_descriptor>(dentry);
           }
-          return kstd::make_shared<kernel::filesystem::byte_offset_file_descriptor>(dentry);
+          return kstd::make_shared<kernel::vfs::byte_offset_file_descriptor>(dentry);
         })
-        .and_then(
-            [](auto file_descriptor) { return kernel::filesystem::open_file_table::get().add_file(file_descriptor); });
+        .and_then([](auto file_descriptor) { return kernel::vfs::open_file_table::get().add_file(file_descriptor); });
   }
 
   auto close(size_t file_descriptor) -> kstd::result<void>
   {
-    return kernel::filesystem::open_file_table::get()
+    return kernel::vfs::open_file_table::get()
         .file(file_descriptor)
         .transform([](auto file) { return file->get_dentry()->absolute_path(); })
-        .and_then([](auto path) { return kernel::filesystem::vfs::get().close(path); })
-        .and_then([=]() { return kernel::filesystem::open_file_table::get().remove_file(file_descriptor); });
+        .and_then([](auto path) { return kernel::vfs::vfs::get().close(path); })
+        .and_then([=]() { return kernel::vfs::open_file_table::get().remove_file(file_descriptor); });
   }
 
   auto read(size_t file_descriptor, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
   {
-    return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
+    return kernel::vfs::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->read(buffer);
     });
   }
 
   auto write(size_t file_descriptor, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>
   {
-    return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
+    return kernel::vfs::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->write(buffer);
     });
   }
 
   auto seek(size_t file_descriptor, kstd::offset offset, seek_origin origin) -> kstd::result<kstd::bytes>
   {
-    return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto file) {
+    return kernel::vfs::open_file_table::get().file(file_descriptor).and_then([=](auto file) {
       return file->seek(offset, origin);
     });
   }
 
   auto mkdir(std::string_view path) -> kstd::result<void>
   {
-    return kernel::filesystem::vfs::get().mkdir(path);
+    return kernel::vfs::vfs::get().mkdir(path);
   }
 
   auto create(std::string_view path) -> kstd::result<void>
   {
-    return kernel::filesystem::vfs::get().create(path);
+    return kernel::vfs::vfs::get().create(path);
   }
 
   auto status(std::string_view path) -> kstd::result<file_status>
   {
-    return kernel::filesystem::vfs::get().status(path);
+    return kernel::vfs::vfs::get().status(path);
   }
 
   auto create_device_node(std::string_view path, file_type type, device_number number) -> kstd::result<void>
   {
-    return kernel::filesystem::vfs::get().create_device_node(path, static_cast<std::uint32_t>(type), number);
+    return kernel::vfs::vfs::get().create_device_node(path, static_cast<std::uint32_t>(type), number);
   }
 
 }  // namespace kapi::filesystem
\ No newline at end of file
diff --git a/kernel/kapi/filesystem.tests.cpp b/kernel/kapi/filesystem.tests.cpp
index 2144af3a..d23255c3 100644
--- a/kernel/kapi/filesystem.tests.cpp
+++ b/kernel/kapi/filesystem.tests.cpp
@@ -1,6 +1,6 @@
 #include <kapi/filesystem.hpp>
 
-#include <kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp>
 
 #include <kstd/system_error.hpp>
 #include <kstd/units.hpp>
@@ -18,7 +18,7 @@ using namespace kstd::units_literals;
 
 // NOLINTBEGIN (readability-magic-numbers)
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Kapi filesystem with real images",
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture, "Kapi filesystem with real images",
                 "[kapi][filesystem]")
 {
   auto const image_path_1 = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
@@ -297,7 +297,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Kap
 
 // NOTE: This must be it's own scenario, because it relies on concrete minor numbers, which in turn depend on global
 // singleton state that only resets on a new scenario.
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture,
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture,
                 "Kapi filesystem resolves a persistent device node to the matching devfs entry", "[kapi][filesystem]")
 {
   auto image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_devnode_fs.img";
diff --git a/kernel/kernel/drivers/pseudo/null.cpp b/kernel/kernel/drivers/pseudo/null.cpp
index d2ae81c6..4c8bde12 100644
--- a/kernel/kernel/drivers/pseudo/null.cpp
+++ b/kernel/kernel/drivers/pseudo/null.cpp
@@ -1,7 +1,7 @@
 #include <kernel/drivers/pseudo/null.hpp>
 
 #include <kernel/bus/pseudo.hpp>
-#include <kernel/filesystem/reserved_numbers.hpp>
+#include <kernel/vfs/reserved_numbers.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/devices/driver_registry.hpp>
@@ -100,14 +100,14 @@ namespace kernel::drivers::pseudo
 
   auto null::claimed_major() const -> std::optional<std::uint8_t>
   {
-    return kernel::filesystem::character_major_numbers::memory;
+    return kernel::vfs::character_major_numbers::memory;
   }
 
   auto null::claimed_minor(kapi::devices::device & device) const -> std::optional<std::uint8_t>
   {
     if (device.name() == "null")
     {
-      return kernel::filesystem::character_minor_numbers::null;
+      return kernel::vfs::character_minor_numbers::null;
     }
     return std::nullopt;
   }
diff --git a/kernel/kernel/drivers/pseudo/zero.cpp b/kernel/kernel/drivers/pseudo/zero.cpp
index 0d5e0f8f..67ec2519 100644
--- a/kernel/kernel/drivers/pseudo/zero.cpp
+++ b/kernel/kernel/drivers/pseudo/zero.cpp
@@ -1,7 +1,7 @@
 #include <kernel/drivers/pseudo/zero.hpp>
 
 #include <kernel/bus/pseudo.hpp>
-#include <kernel/filesystem/reserved_numbers.hpp>
+#include <kernel/vfs/reserved_numbers.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/filesystem.hpp>
@@ -101,14 +101,14 @@ namespace kernel::drivers::pseudo
 
   auto zero::claimed_major() const -> std::optional<std::uint8_t>
   {
-    return kernel::filesystem::character_major_numbers::memory;
+    return kernel::vfs::character_major_numbers::memory;
   }
 
   auto zero::claimed_minor(kapi::devices::device & device) const -> std::optional<std::uint8_t>
   {
     if (device.name() == "zero")
     {
-      return kernel::filesystem::character_minor_numbers::zero;
+      return kernel::vfs::character_minor_numbers::zero;
     }
     return std::nullopt;
   }
diff --git a/kernel/kernel/drivers/storage/ram_disk.cpp b/kernel/kernel/drivers/storage/ram_disk.cpp
index 383a9417..80f7eedc 100644
--- a/kernel/kernel/drivers/storage/ram_disk.cpp
+++ b/kernel/kernel/drivers/storage/ram_disk.cpp
@@ -1,7 +1,7 @@
 #include <kernel/drivers/storage/ram_disk.hpp>
 
 #include <kernel/devices/block_device_utils.hpp>
-#include <kernel/filesystem/reserved_numbers.hpp>
+#include <kernel/vfs/reserved_numbers.hpp>
 
 #include <kapi/boot_modules.hpp>
 #include <kapi/devices.hpp>
@@ -147,7 +147,7 @@ namespace kernel::drivers::storage
 
   auto ram_disk::claimed_major() const -> std::optional<std::uint8_t>
   {
-    return kernel::filesystem::block_major_numbers::ram_disk;
+    return kernel::vfs::block_major_numbers::ram_disk;
   }
 
   auto ram_disk::name() const noexcept -> std::string_view
diff --git a/kernel/kernel/filesystem/devfs/inode.hpp b/kernel/kernel/filesystem/devfs/inode.hpp
deleted file mode 100644
index b83d484c..00000000
--- a/kernel/kernel/filesystem/devfs/inode.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DEVFS_INODE_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DEVFS_INODE_HPP
-
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/inode.hpp>
-
-#include <kstd/result.hpp>
-#include <kstd/units.hpp>
-
-#include <cstddef>
-#include <span>
-#include <utility>
-
-namespace kernel::filesystem::devfs
-{
-  //! Inode implementation for the devfs filesystem.
-  //!
-  //! This inode represents root device node in the /dev directory.
-  struct inode final : kernel::filesystem::inode
-  {
-    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
-        -> kstd::result<kstd::bytes> override;
-
-    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
-
-    [[nodiscard]] auto is_directory() const -> bool override;
-
-    [[nodiscard]] auto read_directory(directory_listing_cursor position,
-                                      std::span<directory_listing_entry> entries) const
-        -> kstd::result<std::pair<std::size_t, directory_listing_cursor>> override;
-  };
-}  // namespace kernel::filesystem::devfs
-
-#endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/devfs/module.cpp b/kernel/kernel/filesystem/devfs/module.cpp
deleted file mode 100644
index a7a1aca9..00000000
--- a/kernel/kernel/filesystem/devfs/module.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <kernel/filesystem/devfs/filesystem.hpp>
-#include <kernel/filesystem/driver_registry.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-
-#include <kstd/memory.hpp>
-
-#include <string_view>
-
-namespace
-{
-
-  struct descriptor final : kernel::filesystem::driver_descriptor
-  {
-    [[nodiscard]] auto name() const noexcept -> std::string_view override
-    {
-      return "devfs";
-    }
-
-    [[nodiscard]] auto make_instance() const -> kernel::filesystem::filesystem::filesystem_ptr override
-    {
-      return kstd::make_shared<kernel::filesystem::devfs::filesystem>();
-    }
-  };
-
-  [[gnu::used]]
-  constexpr auto registration = kernel::filesystem::driver_module<descriptor>{};
-
-}  // namespace
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/error.hpp b/kernel/kernel/filesystem/error.hpp
deleted file mode 100644
index 6b167355..00000000
--- a/kernel/kernel/filesystem/error.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_ERROR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_ERROR_HPP
-
-#include <kstd/system_error.hpp>
-
-#include <type_traits>
-
-namespace kernel::filesystem
-{
-
-  enum struct vfs_errc : int
-  {
-    invalid_path = 1,
-    no_such_file_or_directory,
-    mount_point_not_found,
-    mount_busy,
-    has_child_mounts,
-    invalid_filesystem,
-    unmount_failed,
-    too_many_symbolic_link_levels,
-    unsupported_filesystem,
-    invalid_file_descriptor,
-    invalid_inode,
-    not_a_directory,
-    is_a_directory,
-    read_only_file_system,
-    file_exists,
-    no_such_device,
-    invalid_argument,
-    not_mounted,
-    invalid_driver_data,
-  };
-
-  [[nodiscard]] auto vfs_category() noexcept -> kstd::error_category const &;
-
-  [[nodiscard]] constexpr auto inline make_error_code(vfs_errc error) noexcept -> kstd::error_code
-  {
-    return {static_cast<int>(error), vfs_category()};
-  }
-
-  [[nodiscard]] constexpr auto inline make_error_condition(vfs_errc error) noexcept -> kstd::error_condition
-  {
-    return {static_cast<int>(error), vfs_category()};
-  }
-
-}  // namespace kernel::filesystem
-
-namespace kstd
-{
-  template<>
-  struct is_error_code_enum<kernel::filesystem::vfs_errc> : std::true_type
-  {
-  };
-}  // namespace kstd
-
-#endif
diff --git a/kernel/kernel/filesystem/ext2/error.hpp b/kernel/kernel/filesystem/ext2/error.hpp
deleted file mode 100644
index edd0d017..00000000
--- a/kernel/kernel/filesystem/ext2/error.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_ERROR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_ERROR_HPP
-
-#include <kernel/filesystem/error.hpp>
-
-#include <kstd/system_error.hpp>
-
-#include <type_traits>
-
-namespace kernel::filesystem::ext2
-{
-
-  enum struct ext2_errc : int
-  {
-    invalid_magic_number = 1,
-    invalid_root_inode,
-    invalid_block_group_index,
-    invalid_block_index,
-    invalid_block_number,
-    failed_to_read_superblock,
-    failed_to_read_block_group_descriptors,
-    not_enough_free_blocks,
-    not_enough_inodes,
-    unsupported_features_present,
-    name_too_long,
-  };
-
-  [[nodiscard]] auto ext2_category() noexcept -> kstd::error_category const &;
-
-  [[nodiscard]] constexpr auto inline make_error_code(ext2_errc error) noexcept -> kstd::error_code
-  {
-    return {static_cast<int>(error), ext2_category()};
-  }
-
-}  // namespace kernel::filesystem::ext2
-
-namespace kstd
-{
-  template<>
-  struct is_error_code_enum<kernel::filesystem::ext2::ext2_errc> : std::true_type
-  {
-  };
-}  // namespace kstd
-
-#endif
diff --git a/kernel/kernel/filesystem/ext2/module.cpp b/kernel/kernel/filesystem/ext2/module.cpp
deleted file mode 100644
index e6b14307..00000000
--- a/kernel/kernel/filesystem/ext2/module.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <kernel/filesystem/driver_registry.hpp>
-#include <kernel/filesystem/ext2/filesystem.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-
-#include <kstd/memory.hpp>
-
-#include <string_view>
-
-namespace
-{
-  struct descriptor final : kernel::filesystem::driver_descriptor
-  {
-    [[nodiscard]] auto name() const noexcept -> std::string_view override
-    {
-      return "ext2";
-    }
-
-    [[nodiscard]] auto make_instance() const -> kernel::filesystem::filesystem::filesystem_ptr override
-    {
-      return kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    }
-  };
-
-  [[gnu::used]]
-  constexpr auto registration = kernel::filesystem::driver_module<descriptor>{};
-}  // namespace
diff --git a/kernel/kernel/filesystem/ext2/mount_state.hpp b/kernel/kernel/filesystem/ext2/mount_state.hpp
deleted file mode 100644
index ba705382..00000000
--- a/kernel/kernel/filesystem/ext2/mount_state.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_MOUNT_STATE_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_MOUNT_STATE_HPP
-
-#include <kernel/filesystem/ext2/block_group_descriptor.hpp>
-#include <kernel/filesystem/ext2/superblock.hpp>
-#include <kernel/filesystem/inode.hpp>
-
-#include <kapi/tracked_mutex.hpp>
-
-#include <kstd/memory.hpp>
-#include <kstd/vector.hpp>
-
-namespace kernel::filesystem::ext2
-{
-
-  struct mount_state
-  {
-    struct superblock superblock{};
-    kstd::vector<block_group_descriptor> block_group_descriptors{};
-    kstd::shared_ptr<kernel::filesystem::inode> backing_inode{};
-    mutable kapi::tracked_mutex lock{};
-  };
-
-}  // namespace kernel::filesystem::ext2
-
-#endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/mount_table.tests.cpp b/kernel/kernel/filesystem/mount_table.tests.cpp
deleted file mode 100644
index bed6cd9d..00000000
--- a/kernel/kernel/filesystem/mount_table.tests.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-#include <kernel/filesystem/mount_table.hpp>
-
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/mount.hpp>
-#include <kernel/test_support/filesystem/filesystem.hpp>
-#include <kernel/test_support/filesystem/inode.hpp>
-
-#include <kstd/memory.hpp>
-#include <kstd/print.hpp>
-#include <kstd/vector.hpp>
-
-#include <catch2/catch_test_macros.hpp>
-
-#include <string_view>
-
-SCENARIO("Mount table construction", "[filesystem][mount_table]")
-{
-  GIVEN("an empty mount table")
-  {
-    kernel::filesystem::mount_table table;
-
-    THEN("removing any mount returns mount_not_found")
-    {
-      REQUIRE(table.remove_mount("/") == kernel::filesystem::mount_table::operation_result::mount_not_found);
-      REQUIRE(table.remove_mount("/any/path") == kernel::filesystem::mount_table::operation_result::mount_not_found);
-    }
-  }
-}
-
-SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem][mount_table]")
-{
-  GIVEN("a mount table and some mounts")
-  {
-    kernel::filesystem::mount_table table;
-
-    auto fs1 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    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 = kernel::filesystem::mount::create(mount_dentry1, fs1, nullptr, nullptr, nullptr);
-
-    auto fs2 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    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 = kernel::filesystem::mount::create(mount_dentry2, fs2, nullptr, nullptr, nullptr);
-
-    table.add_mount(*mount1);
-    table.add_mount(*mount2);
-
-    THEN("dentry flags are set correctly for mounted dentries")
-    {
-      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")
-    {
-      REQUIRE(table.find_mount("/") == mount1);
-      REQUIRE(table.find_mount("/mnt") == mount2);
-    }
-
-    THEN("finding mounts by exact invalid path returns null")
-    {
-      REQUIRE(table.find_mount("/nonexistent") == nullptr);
-      REQUIRE(table.find_mount("/mnt/file") == nullptr);
-    }
-
-    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::is_mount_point));
-    }
-
-    THEN("removing a mount that does not exist returns mount_not_found")
-    {
-      REQUIRE(table.remove_mount("/nonexistent") == kernel::filesystem::mount_table::operation_result::mount_not_found);
-    }
-  }
-
-  GIVEN("multiple mounts with the same path")
-  {
-    kernel::filesystem::mount_table table;
-
-    auto fs1 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    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 = kernel::filesystem::mount::create(mount_dentry1, fs1, nullptr, nullptr, nullptr);
-
-    auto fs2 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    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 = kernel::filesystem::mount::create(mount_dentry2, fs2, nullptr, nullptr, nullptr);
-
-    table.add_mount(*mount1);
-    table.add_mount(*mount2);
-
-    THEN("finding mounts by exact valid path returns the correct mount")
-    {
-      REQUIRE(table.find_mount("/") == mount2);
-    }
-
-    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::is_mount_point));
-    }
-  }
-
-  GIVEN("a mount with child mounts")
-  {
-    kernel::filesystem::mount_table table;
-
-    auto fs1 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    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 = kernel::filesystem::mount::create(mount_dentry1, fs1, nullptr, nullptr, nullptr);
-
-    auto fs2 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    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 = kernel::filesystem::mount::create(mount_dentry2, fs2, *mount1, nullptr, nullptr);
-
-    auto fs3 = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    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 = kernel::filesystem::mount::create(mount_dentry3, fs3, *mount2, nullptr, nullptr);
-
-    table.add_mount(*mount1);
-    table.add_mount(*mount2);
-    table.add_mount(*mount3);
-
-    THEN("removing a mount with child mounts returns has_child_mounts")
-    {
-      REQUIRE(table.remove_mount("/") == kernel::filesystem::mount_table::operation_result::has_child_mounts);
-      REQUIRE(table.remove_mount("/mnt") == kernel::filesystem::mount_table::operation_result::has_child_mounts);
-    }
-
-    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::is_mount_point));
-    }
-  }
-}
-
-SCENARIO("Mount reference counting", "[filesystem][mount_table]")
-{
-  kernel::filesystem::mount_table table;
-
-  GIVEN("a filesystem and a root dentry")
-  {
-    auto fs = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode, "/");
-
-    auto source_mount = kernel::filesystem::mount::create(root_dentry, fs, nullptr, nullptr, nullptr);
-    auto mount = kernel::filesystem::mount::create(root_dentry, fs, nullptr, *source_mount, nullptr);
-
-    THEN("reference count of source mount is incremented when a mount is added to the mount table and decremented when "
-         "the mount is removed")
-    {
-      REQUIRE((*source_mount)->ref_count() == 0);
-
-      table.add_mount(*mount);
-      REQUIRE((*source_mount)->ref_count() == 1);
-
-      REQUIRE(table.remove_mount("/") == kernel::filesystem::mount_table::operation_result::removed);
-      REQUIRE((*source_mount)->ref_count() == 0);
-    }
-  }
-}
diff --git a/kernel/kernel/filesystem/path.tests.cpp b/kernel/kernel/filesystem/path.tests.cpp
deleted file mode 100644
index 7bba371b..00000000
--- a/kernel/kernel/filesystem/path.tests.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#include <kernel/filesystem/path.hpp>
-
-#include <catch2/catch_test_macros.hpp>
-
-#include <algorithm>
-#include <string>
-#include <string_view>
-#include <vector>
-
-SCENARIO("path utilities", "[filesystem][path]")
-{
-  GIVEN("valid and invalid paths")
-  {
-    THEN("valid absolute paths are recognized as valid")
-    {
-      REQUIRE(kernel::filesystem::path::is_valid_path("/valid/absolute/path"));
-      REQUIRE(kernel::filesystem::path::is_valid_path("/"));
-    }
-
-    THEN("valid relative paths are recognized as valid")
-    {
-      REQUIRE(kernel::filesystem::path::is_valid_path("valid/../relative/.././path"));
-      REQUIRE(kernel::filesystem::path::is_valid_path("valid/relative/path"));
-      REQUIRE(kernel::filesystem::path::is_valid_path("file.txt"));
-    }
-
-    THEN("invalid paths are recognized as invalid")
-    {
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_path(""));
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_path(std::string(4096, 'a')));
-    }
-
-    THEN("valid absolute paths are recognized as absolute")
-    {
-      REQUIRE(kernel::filesystem::path::is_valid_absolute_path("/valid/absolute/path"));
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_absolute_path("valid/relative/path"));
-    }
-
-    THEN("invalid paths are not recognized as absolute")
-    {
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_absolute_path(""));
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_absolute_path(std::string(4096, 'a')));
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_absolute_path("invalid/absolute/path"));
-    }
-
-    THEN("valid relative paths are recognized as relative")
-    {
-      REQUIRE(kernel::filesystem::path::is_valid_relative_path("valid/relative/path"));
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_relative_path("/valid/absolute/path"));
-    }
-
-    THEN("invalid paths are not recognized as relative")
-    {
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_relative_path(""));
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_relative_path(std::string(4096, 'a')));
-      REQUIRE_FALSE(kernel::filesystem::path::is_valid_relative_path("/invalid/absolute/path"));
-    }
-  }
-
-  GIVEN("a valid path")
-  {
-    THEN("it can be split into components")
-    {
-      auto components = kernel::filesystem::path::split("/a/b///c/d.txt");
-      std::vector<std::string_view> expected = {"a", "b", "c", "d.txt"};
-      REQUIRE(std::ranges::equal(components, expected));
-    }
-  }
-
-  GIVEN("file paths")
-  {
-    THEN("path is split into parent path and filename")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("/a/b/c/d.txt");
-      REQUIRE(parent == "/a/b/c");
-      REQUIRE(filename == "d.txt");
-    }
-
-    THEN("root path is split into root and empty filename")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("/");
-      REQUIRE(parent == "/");
-      REQUIRE(filename == "");
-    }
-
-    THEN("file directly under root is split correctly")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("/file.txt");
-      REQUIRE(parent == "/");
-      REQUIRE(filename == "file.txt");
-    }
-
-    THEN("filename without parent path is split into empty parent and filename")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("file.txt");
-      REQUIRE(parent == "");
-      REQUIRE(filename == "file.txt");
-    }
-
-    THEN("path with trailing slash is split correctly")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("/a/b/c/");
-      REQUIRE(parent == "/a/b");
-      REQUIRE(filename == "c");
-    }
-
-    THEN("single component with trailing slash has root as parent")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("/a/");
-      REQUIRE(parent == "/");
-      REQUIRE(filename == "a");
-    }
-
-    THEN("relative path is split into relative parent and filename")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("a/b/c.txt");
-      REQUIRE(parent == "a/b");
-      REQUIRE(filename == "c.txt");
-    }
-
-    THEN("an empty path is split into empty parent and filename")
-    {
-      auto [parent, filename] = kernel::filesystem::path::split_into_path_and_filename("");
-      REQUIRE(parent == "");
-      REQUIRE(filename == "");
-    }
-  }
-}
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/rootfs/inode.hpp b/kernel/kernel/filesystem/rootfs/inode.hpp
deleted file mode 100644
index fdef0df4..00000000
--- a/kernel/kernel/filesystem/rootfs/inode.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_ROOTFS_INODE_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_ROOTFS_INODE_HPP
-
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/inode.hpp>
-
-#include <kstd/memory.hpp>
-#include <kstd/result.hpp>
-#include <kstd/string.hpp>
-#include <kstd/units.hpp>
-#include <kstd/vector.hpp>
-
-#include <cstddef>
-#include <span>
-#include <utility>
-
-namespace kernel::filesystem::rootfs
-{
-  //! An inode in the rootfs filesystem.
-  struct inode : kernel::filesystem::inode
-  {
-    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
-        -> kstd::result<kstd::bytes> override;
-
-    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
-
-    [[nodiscard]] auto is_directory() const -> bool override;
-
-    [[nodiscard]] auto read_directory(directory_listing_cursor position,
-                                      std::span<directory_listing_entry> entries) const
-        -> kstd::result<std::pair<std::size_t, directory_listing_cursor>> override;
-  };
-}  // namespace kernel::filesystem::rootfs
-
-#endif
diff --git a/kernel/kernel/filesystem/rootfs/module.cpp b/kernel/kernel/filesystem/rootfs/module.cpp
deleted file mode 100644
index 464120b2..00000000
--- a/kernel/kernel/filesystem/rootfs/module.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <kernel/filesystem/driver_registry.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/rootfs/filesystem.hpp>
-
-#include <kstd/memory.hpp>
-
-#include <string_view>
-
-namespace
-{
-
-  struct descriptor final : kernel::filesystem::driver_descriptor
-  {
-    [[nodiscard]] auto name() const noexcept -> std::string_view override
-    {
-      return "rootfs";
-    }
-
-    [[nodiscard]] auto make_instance() const -> kernel::filesystem::filesystem::filesystem_ptr override
-    {
-      return kstd::make_shared<kernel::filesystem::rootfs::filesystem>();
-    }
-  };
-
-  [[gnu::used]]
-  constexpr auto registration = kernel::filesystem::driver_module<descriptor>{};
-
-}  // namespace
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/devfs/filesystem.cpp b/kernel/kernel/filesystems/devfs/filesystem.cpp
index 0de513a7..b6a3c084 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.cpp
+++ b/kernel/kernel/filesystems/devfs/filesystem.cpp
@@ -1,11 +1,11 @@
-#include <kernel/filesystem/devfs/filesystem.hpp>
+#include <kernel/filesystems/devfs/filesystem.hpp>
 
-#include <kernel/filesystem/devfs/inode.hpp>
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/device_number_registry.hpp>
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/filesystems/devfs/inode.hpp>
+#include <kernel/vfs/device_inode.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -18,16 +18,16 @@
 #include <optional>
 #include <string_view>
 
-namespace kernel::filesystem::devfs
+namespace kernel::filesystems::devfs
 {
 
-  static_assert(sizeof(kernel::filesystem::filesystem) == sizeof(devfs::filesystem));
+  static_assert(sizeof(kernel::vfs::filesystem) == sizeof(devfs::filesystem));
 
   auto filesystem::probe(inode_ptr const & inode) const -> kstd::result<std::uint32_t>
   {
     if (inode)
     {
-      return kstd::failure(vfs_errc::invalid_argument);
+      return kstd::failure(vfs::errc::invalid_argument);
     }
 
     return 0;
@@ -44,39 +44,39 @@ namespace kernel::filesystem::devfs
   {
     if (!parent)
     {
-      return kstd::failure(vfs_errc::invalid_inode);
+      return kstd::failure(vfs::errc::invalid_inode);
     }
 
     if (!parent->is_directory())
     {
-      return kstd::failure(vfs_errc::not_a_directory);
+      return kstd::failure(vfs::errc::not_a_directory);
     }
 
     if (parent.get() != driver_data.get())
     {
-      return kstd::failure(vfs_errc::invalid_inode);
+      return kstd::failure(vfs::errc::invalid_inode);
     }
 
-    auto entries = device_number_registry::get().all();
+    auto entries = vfs::device_number_registry::get().all();
     auto found = std::ranges::find_if(entries, [&](auto const & entry) { return entry.name == name; });
 
     if (found == entries.end())
     {
-      return kstd::failure(vfs_errc::no_such_file_or_directory);
+      return kstd::failure(vfs::errc::no_such_file_or_directory);
     }
 
     if (auto device = found->device.lock())
     {
-      return kstd::make_shared<device_inode>(device);
+      return kstd::make_shared<vfs::device_inode>(device);
     }
 
-    return kstd::failure(vfs_errc::no_such_file_or_directory);
+    return kstd::failure(vfs::errc::no_such_file_or_directory);
   }
 
   auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type, driver_data_ptr,
                                 std::optional<kapi::filesystem::device_number>) -> kstd::result<inode_ptr>
   {
-    return kstd::failure(vfs_errc::read_only_file_system);
+    return kstd::failure(vfs::errc::read_only_file_system);
   }
 
-}  // namespace kernel::filesystem::devfs
\ No newline at end of file
+}  // namespace kernel::filesystems::devfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/devfs/filesystem.hpp b/kernel/kernel/filesystems/devfs/filesystem.hpp
index aa33c58b..af9a973a 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.hpp
+++ b/kernel/kernel/filesystems/devfs/filesystem.hpp
@@ -1,11 +1,11 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DEVFS_FILESYSTEM_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DEVFS_FILESYSTEM_HPP
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_DEVFS_FILESYSTEM_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_DEVFS_FILESYSTEM_HPP
 
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/device_number_registry.hpp>
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/device_inode.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -18,7 +18,7 @@
 #include <optional>
 #include <string_view>
 
-namespace kernel::filesystem::devfs
+namespace kernel::filesystems::devfs
 {
 
   //! A filesystem for managing device nodes in the virtual filesystem.
@@ -27,7 +27,7 @@ namespace kernel::filesystem::devfs
   //! applications to interact with devices using standard file operations. The devfs filesystem dynamically creates
   //! inodes for devices registered in the system, enabling seamless access to device functionality through the
   //! filesystem interface.
-  struct filesystem final : kernel::filesystem::filesystem
+  struct filesystem final : kernel::vfs::filesystem
   {
     [[nodiscard]] auto probe(inode_ptr const & inode) const -> kstd::result<std::uint32_t> override;
 
@@ -36,13 +36,11 @@ namespace kernel::filesystem::devfs
     [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) const
         -> kstd::result<inode_ptr> override;
 
-    //! @copydoc kernel::filesystem::filesystem::create_inode
-    //! @return Always returns an error, as creating new inodes is not supported in devfs.
     [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
                                     driver_data_ptr driver_data,
                                     std::optional<kapi::filesystem::device_number> raw_device = std::nullopt)
         -> kstd::result<inode_ptr> override;
   };
-}  // namespace kernel::filesystem::devfs
+}  // namespace kernel::filesystems::devfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/devfs/filesystem.tests.cpp b/kernel/kernel/filesystems/devfs/filesystem.tests.cpp
index ec0c1144..771ba247 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.tests.cpp
+++ b/kernel/kernel/filesystems/devfs/filesystem.tests.cpp
@@ -1,9 +1,9 @@
-#include <kernel/filesystem/devfs/filesystem.hpp>
+#include <kernel/filesystems/devfs/filesystem.hpp>
 
-#include <kernel/filesystem/filesystem.hpp>
 #include <kernel/test_support/devices/block_device.hpp>
 #include <kernel/test_support/devices/driver.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
+#include <kernel/vfs/filesystem.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/filesystem.hpp>
@@ -17,14 +17,14 @@
 
 using namespace kstd::units_literals;
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture,
                 "Devfs filesystem lookup uses storage management devices", "[filesystem][devfs]")
 {
   GIVEN("a boot module registry with one module")
   {
     setup_modules(1);
 
-    auto fs = kstd::make_shared<kernel::filesystem::devfs::filesystem>();
+    auto fs = kstd::make_shared<kernel::filesystems::devfs::filesystem>();
     auto mount = fs->mount(nullptr);
     REQUIRE(mount);
     auto [root, driver_data] = *mount;
@@ -45,7 +45,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
 
     THEN("lookup with wrong parent returns error")
     {
-      auto other_fs = kstd::make_shared<kernel::filesystem::devfs::filesystem>();
+      auto other_fs = kstd::make_shared<kernel::filesystems::devfs::filesystem>();
       auto other_root = other_fs->mount(nullptr);
       CHECK(other_root);
 
@@ -74,7 +74,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
   {
     setup_modules(3, 2048);
 
-    auto fs = kstd::make_shared<kernel::filesystem::devfs::filesystem>();
+    auto fs = kstd::make_shared<kernel::filesystems::devfs::filesystem>();
     auto mount = fs->mount(nullptr);
     REQUIRE(mount);
     auto [root, driver_data] = *mount;
@@ -93,7 +93,7 @@ SCENARIO("Devfs filesystem updates", "[filesystem][devfs]")
 {
   GIVEN("A mounted devfs, and a bus attached to the root without a device attached")
   {
-    auto fs = kstd::make_shared<kernel::filesystem::devfs::filesystem>();
+    auto fs = kstd::make_shared<kernel::filesystems::devfs::filesystem>();
     auto mount = fs->mount(nullptr);
     REQUIRE(mount);
     auto [root, driver_data] = *mount;
diff --git a/kernel/kernel/filesystem/devfs/inode.cpp b/kernel/kernel/filesystems/devfs/inode.cpp
index 8813eb2a..01ce185f 100644
--- a/kernel/kernel/filesystem/devfs/inode.cpp
+++ b/kernel/kernel/filesystems/devfs/inode.cpp
@@ -1,9 +1,9 @@
-#include <kernel/filesystem/devfs/inode.hpp>
+#include <kernel/filesystems/devfs/inode.hpp>
 
-#include <kernel/filesystem/device_number_registry.hpp>
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/error.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -23,11 +23,11 @@
 
 using namespace kstd::units_literals;
 
-namespace kernel::filesystem::devfs
+namespace kernel::filesystems::devfs
 {
   namespace
   {
-    constexpr auto static sentinel = directory_listing_cursor{std::numeric_limits<std::uint64_t>::max()};
+    constexpr auto static sentinel = vfs::directory_listing_cursor{std::numeric_limits<std::uint64_t>::max()};
   }
 
   auto inode::read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes>
@@ -45,13 +45,14 @@ namespace kernel::filesystem::devfs
     return true;
   }
 
-  auto inode::read_directory(directory_listing_cursor position, std::span<directory_listing_entry> entries) const
-      -> kstd::result<std::pair<std::size_t, directory_listing_cursor>>
+  auto inode::read_directory(vfs::directory_listing_cursor position,
+                             std::span<vfs::directory_listing_entry> entries) const
+      -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>>
   {
     auto const requested = entries.size();
     if (requested == 0)
     {
-      return kstd::failure(vfs_errc::invalid_argument);
+      return kstd::failure(vfs::errc::invalid_argument);
     }
 
     if (position == sentinel)
@@ -59,18 +60,18 @@ namespace kernel::filesystem::devfs
       return std::pair{0, sentinel};
     }
 
-    auto devices = kernel::filesystem::device_number_registry::get().all();
+    auto devices = vfs::device_number_registry::get().all();
     if (devices.empty())
     {
       return std::pair{0, position};
     }
 
-    std::ranges::stable_sort(devices, std::ranges::less{}, &kernel::filesystem::device_number_registry::entry::number);
+    std::ranges::stable_sort(devices, std::ranges::less{}, &vfs::device_number_registry::entry::number);
 
     auto const device_number = kapi::filesystem::device_number{static_cast<std::uint8_t>(position.value >> 8),
                                                                static_cast<std::uint8_t>(position.value & 0xff)};
     auto const begin = std::ranges::lower_bound(devices, device_number, std::ranges::less{},
-                                                &kernel::filesystem::device_number_registry::entry::number);
+                                                &vfs::device_number_registry::entry::number);
     auto const end = std::ranges::end(devices);
     auto const to_read = std::min(requested, static_cast<std::size_t>(std::ranges::distance(begin, end)));
 
@@ -80,9 +81,11 @@ namespace kernel::filesystem::devfs
     }
 
     std::ranges::transform(begin, begin + to_read, std::ranges::begin(entries), [](auto const & entry) {
-      return directory_listing_entry{.name = entry.name,
-                                     .type = entry.type,
-                                     .inode_number = std::bit_cast<std::uint16_t>(entry.number)};
+      return vfs::directory_listing_entry{
+        .name = entry.name,
+        .type = entry.type,
+        .inode_number = std::bit_cast<std::uint16_t>(entry.number),
+      };
     });
 
     auto const last_copied = begin + to_read;
@@ -92,8 +95,8 @@ namespace kernel::filesystem::devfs
     }
 
     auto const new_device_number = last_copied->number;
-    auto const new_cursor = directory_listing_cursor{static_cast<std::uint64_t>(new_device_number.minor) |
-                                                     (static_cast<std::uint64_t>(new_device_number.major) << 8)};
+    auto const new_cursor = vfs::directory_listing_cursor{static_cast<std::uint64_t>(new_device_number.minor) |
+                                                          (static_cast<std::uint64_t>(new_device_number.major) << 8)};
     return std::pair{to_read, new_cursor};
   }
-}  // namespace kernel::filesystem::devfs
\ No newline at end of file
+}  // namespace kernel::filesystems::devfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystems/devfs/inode.hpp b/kernel/kernel/filesystems/devfs/inode.hpp
new file mode 100644
index 00000000..a4bbccfa
--- /dev/null
+++ b/kernel/kernel/filesystems/devfs/inode.hpp
@@ -0,0 +1,35 @@
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_DEVFS_INODE_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_DEVFS_INODE_HPP
+
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/inode.hpp>
+
+#include <kstd/result.hpp>
+#include <kstd/units.hpp>
+
+#include <cstddef>
+#include <span>
+#include <utility>
+
+namespace kernel::filesystems::devfs
+{
+  //! Inode implementation for the devfs filesystem.
+  //!
+  //! This inode represents root device node in the /dev directory.
+  struct inode final : kernel::vfs::inode
+  {
+    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> override;
+
+    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
+
+    [[nodiscard]] auto is_directory() const -> bool override;
+
+    [[nodiscard]] auto read_directory(vfs::directory_listing_cursor position,
+                                      std::span<vfs::directory_listing_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>> override;
+  };
+}  // namespace kernel::filesystems::devfs
+
+#endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/devfs/inode.tests.cpp b/kernel/kernel/filesystems/devfs/inode.tests.cpp
index 581bf6c5..956db26b 100644
--- a/kernel/kernel/filesystem/devfs/inode.tests.cpp
+++ b/kernel/kernel/filesystems/devfs/inode.tests.cpp
@@ -1,10 +1,10 @@
-#include <kernel/filesystem/devfs/inode.hpp>
+#include <kernel/filesystems/devfs/inode.hpp>
 
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
 #include <kernel/test_support/devices/block_device.hpp>
 #include <kernel/test_support/devices/driver.hpp>
+#include <kernel/vfs/device_inode.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/filesystem.hpp>
@@ -41,7 +41,7 @@ SCENARIO("Devfs inode creation", "[filesystem][devfs][inode]")
 {
   GIVEN("a devfs inode")
   {
-    auto inode = kernel::filesystem::devfs::inode{};
+    auto inode = kernel::filesystems::devfs::inode{};
 
     THEN("the inode has the correct kind")
     {
@@ -57,7 +57,7 @@ SCENARIO("Devfs inode read/write", "[filesystem][devfs][inode]")
 {
   GIVEN("a devfs inode")
   {
-    auto inode = kernel::filesystem::devfs::inode{};
+    auto inode = kernel::filesystems::devfs::inode{};
 
     WHEN("attempting to read from the devfs inode")
     {
@@ -87,12 +87,12 @@ SCENARIO("Devfs inode directory listing", "[filesystem][devfs][inode]")
 {
   GIVEN("a devfs inode and no registered devices")
   {
-    auto root = kernel::filesystem::devfs::inode{};
+    auto root = kernel::filesystems::devfs::inode{};
 
     THEN("the directory listing is empty")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>{4};
-      auto result = root.read_directory(kernel::filesystem::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>{4};
+      auto result = root.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
 
       REQUIRE(result);
       auto [count, next] = *result;
@@ -102,7 +102,7 @@ SCENARIO("Devfs inode directory listing", "[filesystem][devfs][inode]")
 
   GIVEN("a devfs inode and three registered devices")
   {
-    auto root = kernel::filesystem::devfs::inode{};
+    auto root = kernel::filesystems::devfs::inode{};
 
     auto bus = kstd::make_shared<kapi::devices::bus>("devfs_readdir_bus");
     kapi::devices::get_root_bus()->add_child(bus);
@@ -113,8 +113,8 @@ SCENARIO("Devfs inode directory listing", "[filesystem][devfs][inode]")
 
     WHEN("the directory listing is requested with a buffer large enough for all of them")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>{4};
-      auto result = root.read_directory(kernel::filesystem::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>{4};
+      auto result = root.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
 
       THEN("all devices are listed")
       {
@@ -148,11 +148,11 @@ SCENARIO("Devfs inode directory listing", "[filesystem][devfs][inode]")
     WHEN("read_directory is called one entry at a time, chaining the returned cursor")
     {
       auto seen = kstd::vector<kstd::string>{};
-      auto position = kernel::filesystem::directory_listing_cursor{};
+      auto position = kernel::vfs::directory_listing_cursor{};
 
       for (auto guard = 0; guard < 4; ++guard)
       {
-        auto one = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
+        auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
         auto result = root.read_directory(position, one);
         REQUIRE(result);
         auto [count, next] = *result;
@@ -183,7 +183,7 @@ SCENARIO("Devfs inode read_directory orders by device number, not registration o
 {
   GIVEN("a device that frees the lowest minor number before a later device reuses it")
   {
-    auto root = kernel::filesystem::devfs::inode{};
+    auto root = kernel::filesystems::devfs::inode{};
 
     auto bus = kstd::make_shared<kapi::devices::bus>("devfs_readdir_reuse_bus");
     kapi::devices::get_root_bus()->add_child(bus);
@@ -195,8 +195,8 @@ SCENARIO("Devfs inode read_directory orders by device number, not registration o
 
     WHEN("read_directory is called with room for both remaining entries")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>(2);
-      auto result = root.read_directory(kernel::filesystem::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(2);
+      auto result = root.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
 
       THEN("later_in (the reused, lower device number) comes back before still_in, by number, not by "
            "when each was registered")
@@ -220,12 +220,12 @@ SCENARIO("Devfs read_directory rejects non-directory inodes", "[filesystem][devf
     auto bus = kstd::make_shared<kapi::devices::bus>("devfs_readdir_nondir_bus");
     kapi::devices::get_root_bus()->add_child(bus);
     auto device = make_and_publish(bus, "readdir_nondir_device");
-    auto node = kernel::filesystem::device_inode{device};
+    auto node = kernel::vfs::device_inode{device};
 
     THEN("read_directory falls through to the base class default rather than enumerating anything")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
-      auto result = node.read_directory(kernel::filesystem::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+      auto result = node.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
 
       REQUIRE_FALSE(result);
     }
diff --git a/kernel/kernel/filesystems/devfs/module.cpp b/kernel/kernel/filesystems/devfs/module.cpp
new file mode 100644
index 00000000..2048caa1
--- /dev/null
+++ b/kernel/kernel/filesystems/devfs/module.cpp
@@ -0,0 +1,28 @@
+#include <kernel/filesystems/devfs/filesystem.hpp>
+#include <kernel/vfs/driver_registry.hpp>
+#include <kernel/vfs/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+
+#include <string_view>
+
+namespace
+{
+
+  struct descriptor final : kernel::vfs::driver_descriptor
+  {
+    [[nodiscard]] auto name() const noexcept -> std::string_view override
+    {
+      return "devfs";
+    }
+
+    [[nodiscard]] auto make_instance() const -> kernel::vfs::filesystem::filesystem_ptr override
+    {
+      return kstd::make_shared<kernel::filesystems::devfs::filesystem>();
+    }
+  };
+
+  [[gnu::used]]
+  constexpr auto registration = kernel::vfs::driver_module<descriptor>{};
+
+}  // namespace
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/ext2/block_group_descriptor.hpp b/kernel/kernel/filesystems/ext2/block_group_descriptor.hpp
index 16f6d6e2..dd9c3317 100644
--- a/kernel/kernel/filesystem/ext2/block_group_descriptor.hpp
+++ b/kernel/kernel/filesystems/ext2/block_group_descriptor.hpp
@@ -1,10 +1,10 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_BLOCK_GROUP_DESCRIPTOR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_BLOCK_GROUP_DESCRIPTOR_HPP
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_BLOCK_GROUP_DESCRIPTOR_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_BLOCK_GROUP_DESCRIPTOR_HPP
 
 #include <array>
 #include <cstdint>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
   //! A block group descriptor in the ext2 filesystem.
   struct [[gnu::packed]] block_group_descriptor
@@ -18,5 +18,5 @@ namespace kernel::filesystem::ext2
     std::array<uint8_t, 2> padding;
     std::array<uint8_t, 12> reserved;  // NOLINT(readability-magic-numbers)
   };
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/ext2/directory_iterator.cpp b/kernel/kernel/filesystems/ext2/directory_iterator.cpp
index 7e2df1e3..1c94a863 100644
--- a/kernel/kernel/filesystem/ext2/directory_iterator.cpp
+++ b/kernel/kernel/filesystems/ext2/directory_iterator.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/ext2/directory_iterator.hpp>
+#include <kernel/filesystems/ext2/directory_iterator.hpp>
 
-#include <kernel/filesystem/ext2/filesystem.hpp>
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
 
 #include <kapi/system.hpp>
 
@@ -11,7 +11,7 @@
 
 using namespace kstd::literals;
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
   directory_iterator::directory_iterator(inode const & inode, mount_state const & state)
@@ -106,4 +106,4 @@ namespace kernel::filesystem::ext2
     m_file_offset = m_file_offset + static_cast<kstd::bytes>(entry->rec_len);
   }
 
-}  // namespace kernel::filesystem::ext2
\ No newline at end of file
+}  // namespace kernel::filesystems::ext2
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/ext2/directory_iterator.hpp b/kernel/kernel/filesystems/ext2/directory_iterator.hpp
index 0ef8d134..41a37e74 100644
--- a/kernel/kernel/filesystem/ext2/directory_iterator.hpp
+++ b/kernel/kernel/filesystems/ext2/directory_iterator.hpp
@@ -1,9 +1,9 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_DIRECTORY_ITERATOR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_DIRECTORY_ITERATOR_HPP
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_DIRECTORY_ITERATOR_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_DIRECTORY_ITERATOR_HPP
 
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/linked_directory_entry.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/linked_directory_entry.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/units.hpp>
@@ -12,7 +12,7 @@
 #include <cstddef>
 #include <iterator>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
   struct directory_iterator
@@ -51,6 +51,6 @@ namespace kernel::filesystem::ext2
     kstd::vector<std::byte> m_buffer{};
   };
 
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/ext2/directory_iterator.tests.cpp b/kernel/kernel/filesystems/ext2/directory_iterator.tests.cpp
index 2ef931d1..795c5cbf 100644
--- a/kernel/kernel/filesystem/ext2/directory_iterator.tests.cpp
+++ b/kernel/kernel/filesystems/ext2/directory_iterator.tests.cpp
@@ -1,12 +1,12 @@
-#include <kernel/filesystem/ext2/directory_iterator.hpp>
+#include <kernel/filesystems/ext2/directory_iterator.hpp>
 
 #include <kernel/devices/storage.hpp>
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/ext2/filesystem.hpp>
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
-#include <kernel/filesystem/mount.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
+#include <kernel/vfs/device_inode.hpp>
+#include <kernel/vfs/mount.hpp>
 
 #include <kstd/memory.hpp>
 
@@ -17,7 +17,7 @@
 #include <string>
 #include <vector>
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture,
                 "Ext2 directory_iterator walks a real directory and terminates", "[filesystem][ext2][readdir]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
@@ -30,23 +30,23 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     auto boot_device = kernel::devices::storage::determine_boot_device();
     REQUIRE(boot_device != nullptr);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(boot_device);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     REQUIRE(mount);
 
     auto root = (*mount)->root_dentry()->inode();
-    auto const & root_ext2_inode = static_cast<kernel::filesystem::ext2::inode const &>(*root);
+    auto const & root_ext2_inode = static_cast<kernel::filesystems::ext2::inode const &>(*root);
 
-    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>((*mount)->driver_data());
+    auto mount_state = static_pointer_cast<kernel::filesystems::ext2::mount_state>((*mount)->driver_data());
 
     WHEN("iterating from begin to the default-constructed end sentinel")
     {
       auto names = std::vector<std::string>{};
       auto guard = 0;
 
-      for (auto it = kernel::filesystem::ext2::directory_iterator{root_ext2_inode, *mount_state};
-           it != kernel::filesystem::ext2::directory_iterator{}; ++it)
+      for (auto it = kernel::filesystems::ext2::directory_iterator{root_ext2_inode, *mount_state};
+           it != kernel::filesystems::ext2::directory_iterator{}; ++it)
       {
         REQUIRE(guard++ < 64);  // fails loudly on a non-terminating loop rather than hanging the suite
         names.emplace_back(&it->name_start, it->name_len);
@@ -63,7 +63,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture,
                 "Ext2 directory_iterator satisfies the forward-iterator multi-pass guarantee",
                 "[filesystem][ext2][readdir]")
 {
@@ -77,17 +77,17 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     auto boot_device = kernel::devices::storage::determine_boot_device();
     REQUIRE(boot_device != nullptr);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(boot_device);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     REQUIRE(mount);
 
     auto root = (*mount)->root_dentry()->inode();
-    auto const & root_ext2_inode = static_cast<kernel::filesystem::ext2::inode const &>(*root);
+    auto const & root_ext2_inode = static_cast<kernel::filesystems::ext2::inode const &>(*root);
 
-    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>((*mount)->driver_data());
+    auto mount_state = static_pointer_cast<kernel::filesystems::ext2::mount_state>((*mount)->driver_data());
 
-    auto original = kernel::filesystem::ext2::directory_iterator{root_ext2_inode, *mount_state};
+    auto original = kernel::filesystems::ext2::directory_iterator{root_ext2_inode, *mount_state};
     auto const first_name = std::string{&original->name_start, original->name_len};
 
     WHEN("the iterator is copied, then only the original is advanced")
@@ -112,8 +112,8 @@ SCENARIO("Ext2 directory_iterator's default-constructed value is a valid, compar
 {
   GIVEN("two independently default-constructed iterators")
   {
-    auto first = kernel::filesystem::ext2::directory_iterator{};
-    auto second = kernel::filesystem::ext2::directory_iterator{};
+    auto first = kernel::filesystems::ext2::directory_iterator{};
+    auto second = kernel::filesystems::ext2::directory_iterator{};
 
     THEN("they compare equal to each other")
     {
diff --git a/kernel/kernel/filesystem/ext2/error.cpp b/kernel/kernel/filesystems/ext2/error.cpp
index 73921379..23b01f4e 100644
--- a/kernel/kernel/filesystem/ext2/error.cpp
+++ b/kernel/kernel/filesystems/ext2/error.cpp
@@ -1,17 +1,17 @@
-#include <kernel/filesystem/ext2/error.hpp>
+#include <kernel/filesystems/ext2/error.hpp>
 
-#include <kernel/filesystem/error.hpp>
+#include <kernel/vfs/error.hpp>
 
 #include <kstd/system_error.hpp>
 
 #include <string_view>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
   namespace
   {
-    struct ext2_category_t final : kstd::error_category
+    struct category_t final : kstd::error_category
     {
       [[nodiscard]] constexpr auto name() const noexcept -> std::string_view override
       {
@@ -20,29 +20,29 @@ namespace kernel::filesystem::ext2
 
       [[nodiscard]] constexpr auto message(int value) const noexcept -> std::string_view override
       {
-        switch (static_cast<ext2_errc>(value))
+        switch (static_cast<errc>(value))
         {
-          case ext2_errc::invalid_magic_number:
+          case errc::invalid_magic_number:
             return "invalid filesystem magic";
-          case ext2_errc::invalid_root_inode:
+          case errc::invalid_root_inode:
             return "invalid root inode";
-          case ext2_errc::invalid_block_group_index:
+          case errc::invalid_block_group_index:
             return "block group index out of bounds";
-          case ext2_errc::invalid_block_index:
+          case errc::invalid_block_index:
             return "block index out of bounds";
-          case ext2_errc::invalid_block_number:
+          case errc::invalid_block_number:
             return "block number out of bounds";
-          case ext2_errc::failed_to_read_superblock:
+          case errc::failed_to_read_superblock:
             return "failed to read superblock";
-          case ext2_errc::failed_to_read_block_group_descriptors:
+          case errc::failed_to_read_block_group_descriptors:
             return "failed to read block group descriptors";
-          case ext2_errc::not_enough_free_blocks:
+          case errc::not_enough_free_blocks:
             return "not enough free blocks";
-          case ext2_errc::not_enough_inodes:
+          case errc::not_enough_inodes:
             return "not enough inodes";
-          case ext2_errc::unsupported_features_present:
+          case errc::unsupported_features_present:
             return "unsupported features present";
-          case ext2_errc::name_too_long:
+          case errc::name_too_long:
             return "name too long";
           default:
             return "unknown ext2 error";
@@ -52,38 +52,38 @@ namespace kernel::filesystem::ext2
       [[nodiscard]] constexpr auto equivalent(int code, kstd::error_condition const & condition) const noexcept
           -> bool override
       {
-        switch (static_cast<ext2_errc>(code))
+        switch (static_cast<errc>(code))
         {
-          case ext2_errc::invalid_magic_number:
-          case ext2_errc::invalid_root_inode:
-          case ext2_errc::name_too_long:
-            if (condition.category() == kernel::filesystem::vfs_category())
+          case errc::invalid_magic_number:
+          case errc::invalid_root_inode:
+          case errc::name_too_long:
+            if (condition.category() == kernel::vfs::category())
             {
-              return condition.value() == static_cast<int>(kernel::filesystem::vfs_errc::invalid_filesystem);
+              return condition.value() == static_cast<int>(kernel::vfs::errc::invalid_filesystem);
             }
             else if (condition.category() == kstd::generic_category())
             {
               return condition.value() == static_cast<int>(kstd::errc::invalid_argument);
             }
             break;
-          case ext2_errc::invalid_block_group_index:
-          case ext2_errc::invalid_block_index:
-          case ext2_errc::invalid_block_number:
-          case ext2_errc::failed_to_read_superblock:
-          case ext2_errc::failed_to_read_block_group_descriptors:
+          case errc::invalid_block_group_index:
+          case errc::invalid_block_index:
+          case errc::invalid_block_number:
+          case errc::failed_to_read_superblock:
+          case errc::failed_to_read_block_group_descriptors:
             if (condition.category() == kstd::generic_category())
             {
               return condition.value() == static_cast<int>(kstd::errc::io_error);
             }
             break;
-          case ext2_errc::not_enough_free_blocks:
-          case ext2_errc::not_enough_inodes:
+          case errc::not_enough_free_blocks:
+          case errc::not_enough_inodes:
             if (condition.category() == kstd::generic_category())
             {
               return condition.value() == static_cast<int>(kstd::errc::no_space_on_device);
             }
             break;
-          case ext2_errc::unsupported_features_present:
+          case errc::unsupported_features_present:
             if (condition.category() == kstd::generic_category())
             {
               return condition.value() == static_cast<int>(kstd::errc::not_supported);
@@ -95,9 +95,9 @@ namespace kernel::filesystem::ext2
     } constexpr inline ext2_category_instance{};
   }  // namespace
 
-  [[nodiscard]] auto ext2_category() noexcept -> kstd::error_category const &
+  [[nodiscard]] auto category() noexcept -> kstd::error_category const &
   {
     return ext2_category_instance;
   }
 
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
diff --git a/kernel/kernel/filesystems/ext2/error.hpp b/kernel/kernel/filesystems/ext2/error.hpp
new file mode 100644
index 00000000..3c767051
--- /dev/null
+++ b/kernel/kernel/filesystems/ext2/error.hpp
@@ -0,0 +1,45 @@
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_ERROR_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_ERROR_HPP
+
+#include <kernel/vfs/error.hpp>
+
+#include <kstd/system_error.hpp>
+
+#include <type_traits>
+
+namespace kernel::filesystems::ext2
+{
+
+  enum struct errc : int
+  {
+    invalid_magic_number = 1,
+    invalid_root_inode,
+    invalid_block_group_index,
+    invalid_block_index,
+    invalid_block_number,
+    failed_to_read_superblock,
+    failed_to_read_block_group_descriptors,
+    not_enough_free_blocks,
+    not_enough_inodes,
+    unsupported_features_present,
+    name_too_long,
+  };
+
+  [[nodiscard]] auto category() noexcept -> kstd::error_category const &;
+
+  [[nodiscard]] constexpr auto inline make_error_code(errc error) noexcept -> kstd::error_code
+  {
+    return {static_cast<int>(error), category()};
+  }
+
+}  // namespace kernel::filesystems::ext2
+
+namespace kstd
+{
+  template<>
+  struct is_error_code_enum<kernel::filesystems::ext2::errc> : std::true_type
+  {
+  };
+}  // namespace kstd
+
+#endif
diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystems/ext2/filesystem.cpp
index 0ddbca79..a2468fcb 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.cpp
@@ -1,16 +1,16 @@
-#include <kernel/filesystem/ext2/filesystem.hpp>
-
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/ext2/block_group_descriptor.hpp>
-#include <kernel/filesystem/ext2/directory_iterator.hpp>
-#include <kernel/filesystem/ext2/error.hpp>
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/linked_directory_entry.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
-#include <kernel/filesystem/ext2/superblock.hpp>
-#include <kernel/filesystem/ext2/write_batch.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
+
+#include <kernel/filesystems/ext2/block_group_descriptor.hpp>
+#include <kernel/filesystems/ext2/directory_iterator.hpp>
+#include <kernel/filesystems/ext2/error.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/linked_directory_entry.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/superblock.hpp>
+#include <kernel/filesystems/ext2/write_batch.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 #include <kapi/system.hpp>
@@ -36,11 +36,11 @@
 
 using namespace kstd::units_literals;
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
   //! Check that this driver class is stateless.
-  static_assert(sizeof(kernel::filesystem::filesystem) == sizeof(kernel::filesystem::ext2::filesystem));
+  static_assert(sizeof(kernel::vfs::filesystem) == sizeof(kernel::filesystems::ext2::filesystem));
 
   //! Hidden implementation details.
   namespace
@@ -215,7 +215,7 @@ namespace kernel::filesystem::ext2
       if (buffer.size() - offset.value < record_size)
       {
         // TODO: improve error code.
-        return kstd::failure(vfs_errc::invalid_argument);
+        return kstd::failure(vfs::errc::invalid_argument);
       }
 
       auto * entry = reinterpret_cast<linked_directory_entry *>(buffer.data() + offset);
@@ -256,7 +256,7 @@ namespace kernel::filesystem::ext2
     {
       if (buffer.size() < block_size(state).value)
       {
-        return kstd::failure(vfs_errc::invalid_argument);
+        return kstd::failure(vfs::errc::invalid_argument);
       }
 
       auto const block_offset = static_cast<size_t>(block_number) * block_size(state);
@@ -274,7 +274,7 @@ namespace kernel::filesystem::ext2
     {
       if (buffer.size() < block_size(state).value)
       {
-        return kstd::failure(vfs_errc::invalid_argument);
+        return kstd::failure(vfs::errc::invalid_argument);
       }
 
       auto const block_offset = static_cast<size_t>(block_number) * block_size(state);
@@ -292,7 +292,7 @@ namespace kernel::filesystem::ext2
 
       if (block_group_descriptors.empty() || superblock.free_inodes_count == 0)
       {
-        return kstd::failure(ext2_errc::not_enough_inodes);
+        return kstd::failure(errc::not_enough_inodes);
       }
 
       for (auto block_group_descriptor_index = 0uz; block_group_descriptor_index < block_group_descriptors.size();
@@ -331,7 +331,7 @@ namespace kernel::filesystem::ext2
         }
       }
 
-      return kstd::failure(ext2_errc::not_enough_inodes);
+      return kstd::failure(errc::not_enough_inodes);
     }
 
     //! Add a new directory entry to a given directory.
@@ -400,7 +400,7 @@ namespace kernel::filesystem::ext2
       {
         if (!directory.append_blocks(1, batch))
         {
-          return kstd::failure(ext2_errc::not_enough_free_blocks);
+          return kstd::failure(errc::not_enough_free_blocks);
         }
 
         auto const new_block_index = block_count(directory, state) - 1;
@@ -449,7 +449,7 @@ namespace kernel::filesystem::ext2
     {
       if (!directory.append_blocks(1, batch))
       {
-        return kstd::failure(ext2_errc::not_enough_free_blocks);
+        return kstd::failure(errc::not_enough_free_blocks);
       }
 
       auto const global_block = inode_block_number(0, directory, state);
@@ -500,7 +500,7 @@ namespace kernel::filesystem::ext2
 
       if (block_group_index >= state.block_group_descriptors.size())
       {
-        return kstd::failure(ext2_errc::invalid_block_group_index);
+        return kstd::failure(errc::invalid_block_group_index);
       }
 
       auto const & block_group_descriptor = state.block_group_descriptors.at(block_group_index);
@@ -594,13 +594,13 @@ namespace kernel::filesystem::ext2
 
     if (superblock.magic != constants::magic_number)
     {
-      return kstd::failure(ext2_errc::invalid_magic_number);
+      return kstd::failure(errc::invalid_magic_number);
     }
 
     if (std::to_underlying(superblock.feature_incompat & ~supported_incompatible_features) ||
         std::to_underlying(superblock.feature_ro_compat & ~supported_ro_compatible_features))
     {
-      return kstd::failure(ext2_errc::unsupported_features_present);
+      return kstd::failure(errc::unsupported_features_present);
     }
 
     return 0;
@@ -621,7 +621,7 @@ namespace kernel::filesystem::ext2
 
     if (superblock.magic != constants::magic_number)
     {
-      return kstd::failure(ext2_errc::invalid_magic_number);
+      return kstd::failure(errc::invalid_magic_number);
     }
 
     auto const blocks_per_group = superblock.blocks_per_group;
@@ -645,7 +645,7 @@ namespace kernel::filesystem::ext2
 
     if (!(*root)->is_directory())
     {
-      return kstd::failure(ext2_errc::invalid_root_inode);
+      return kstd::failure(errc::invalid_root_inode);
     }
 
     return mount_result{*root, mount_state};
@@ -657,18 +657,18 @@ namespace kernel::filesystem::ext2
     auto const directory = static_pointer_cast<inode>(parent);
     if (!directory)
     {
-      return kstd::failure(vfs_errc::invalid_inode);
+      return kstd::failure(vfs::errc::invalid_inode);
     }
 
     if (!directory->is_directory())
     {
-      return kstd::failure(vfs_errc::not_a_directory);
+      return kstd::failure(vfs::errc::not_a_directory);
     }
 
     auto const mount_state = static_pointer_cast<struct mount_state>(driver_data);
     if (!mount_state)
     {
-      return kstd::failure(vfs_errc::not_mounted);
+      return kstd::failure(vfs::errc::not_mounted);
     }
 
     auto guard = kstd::lock_guard{mount_state->lock};
@@ -686,34 +686,34 @@ namespace kernel::filesystem::ext2
       }
     }
 
-    return kstd::failure(vfs_errc::no_such_file_or_directory);
+    return kstd::failure(vfs::errc::no_such_file_or_directory);
   }
 
   auto filesystem::create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
                                 driver_data_ptr driver_data, std::optional<kapi::filesystem::device_number> raw_device)
-      -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>>
+      -> kstd::result<kstd::shared_ptr<kernel::vfs::inode>>
   {
     auto const ext2_parent = static_pointer_cast<inode>(parent);
     if (!ext2_parent)
     {
-      return kstd::failure(vfs_errc::invalid_argument);
+      return kstd::failure(vfs::errc::invalid_argument);
     }
 
     if (!ext2_parent->is_directory())
     {
-      return kstd::failure(vfs_errc::not_a_directory);
+      return kstd::failure(vfs::errc::not_a_directory);
     }
 
     auto const is_device = kapi::filesystem::is_device(type);
     if (is_device && !raw_device)
     {
-      return kstd::failure(vfs_errc::invalid_argument);
+      return kstd::failure(vfs::errc::invalid_argument);
     }
 
     auto const mount_state = static_pointer_cast<struct mount_state>(driver_data);
     if (!mount_state)
     {
-      return kstd::failure(vfs_errc::invalid_driver_data);
+      return kstd::failure(vfs::errc::invalid_driver_data);
     }
 
     auto guard = kstd::lock_guard{mount_state->lock};
@@ -855,7 +855,7 @@ namespace kernel::filesystem::ext2
 
     if (block_group_descriptors.empty() || count > superblock.free_blocks_count)
     {
-      return kstd::failure(ext2_errc::not_enough_free_blocks);
+      return kstd::failure(errc::not_enough_free_blocks);
     }
 
     struct pending_group
@@ -902,7 +902,7 @@ namespace kernel::filesystem::ext2
 
     if (allocated_blocks.size() != count)
     {
-      return kstd::failure(ext2_errc::not_enough_free_blocks);
+      return kstd::failure(errc::not_enough_free_blocks);
     }
 
     for (auto & group : pending)
@@ -993,7 +993,7 @@ namespace kernel::filesystem::ext2
       return block_number;
     }
 
-    return kstd::failure(ext2_errc::invalid_block_index);
+    return kstd::failure(errc::invalid_block_index);
   }
 
   auto write_global_block_number_to_inode_block_index(size_t inode_block_index, inode_data & data,
@@ -1100,4 +1100,4 @@ namespace kernel::filesystem::ext2
 
   //! @}
 
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystems/ext2/filesystem.hpp
index 85ce4624..cdf552c9 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.hpp
@@ -1,15 +1,15 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_FILESYSTEM_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_FILESYSTEM_HPP
-
-#include <kernel/filesystem/ext2/block_group_descriptor.hpp>
-#include <kernel/filesystem/ext2/directory_iterator.hpp>
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/linked_directory_entry.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
-#include <kernel/filesystem/ext2/superblock.hpp>
-#include <kernel/filesystem/ext2/write_batch.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_FILESYSTEM_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_FILESYSTEM_HPP
+
+#include <kernel/filesystems/ext2/block_group_descriptor.hpp>
+#include <kernel/filesystems/ext2/directory_iterator.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/linked_directory_entry.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/superblock.hpp>
+#include <kernel/filesystems/ext2/write_batch.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -25,7 +25,7 @@
 #include <span>
 #include <string_view>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
   //! Constants related to the ext2 filesystem.
   namespace constants
@@ -56,7 +56,7 @@ namespace kernel::filesystem::ext2
   }  // namespace constants
 
   //! The Second Extended Filesystem (ext2)
-  struct filesystem final : kernel::filesystem::filesystem
+  struct filesystem final : kernel::vfs::filesystem
   {
     //! @name Driver Interface Implementation
     //! @{
@@ -159,6 +159,6 @@ namespace kernel::filesystem::ext2
                                                   size_t block_group_descriptor_index, mount_state const & state)
       -> kstd::result<void>;
   [[nodiscard]] auto write_superblock(mount_state & state) -> kstd::result<void>;
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
 
 #endif
diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystems/ext2/filesystem.tests.cpp
index 8565db4d..4ace4e3d 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystems/ext2/filesystem.tests.cpp
@@ -1,20 +1,20 @@
-#include <kernel/filesystem/ext2/filesystem.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
 
 #include <kernel/devices/storage.hpp>
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/ext2/block_group_descriptor.hpp>
-#include <kernel/filesystem/ext2/error.hpp>
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
-#include <kernel/filesystem/ext2/superblock.hpp>
-#include <kernel/filesystem/ext2/write_batch.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
-#include <kernel/filesystem/mount.hpp>
+#include <kernel/filesystems/ext2/block_group_descriptor.hpp>
+#include <kernel/filesystems/ext2/error.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/superblock.hpp>
+#include <kernel/filesystems/ext2/write_batch.hpp>
 #include <kernel/test_support/cpu.hpp>
 #include <kernel/test_support/devices/block_device.hpp>
-#include <kernel/test_support/filesystem/ext2.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
+#include <kernel/test_support/filesystems/ext2.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
+#include <kernel/vfs/device_inode.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
+#include <kernel/vfs/mount.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -36,8 +36,8 @@ using namespace kstd::units_literals;
 
 // NOLINTBEGIN(readability-magic-numbers)
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
-                "Ext2 filesystem mount and lookup with real image", "[filesystem][ext2][filesystem][img]")
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture, "Ext2 filesystem mount and lookup with real image",
+                "[filesystem][ext2][filesystem][img]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
 
@@ -49,10 +49,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     auto boot_device = kernel::devices::storage::determine_boot_device();
     REQUIRE(boot_device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(boot_device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
@@ -93,8 +93,8 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
-                "Ext2 filesystem create new inodes with real image", "[filesystem][ext2][filesystem][img]")
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture, "Ext2 filesystem create new inodes with real image",
+                "[filesystem][ext2][filesystem][img]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
 
@@ -106,10 +106,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     auto boot_device = kernel::devices::storage::determine_boot_device();
     REQUIRE(boot_device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(boot_device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
@@ -187,13 +187,13 @@ SCENARIO("Ext2 filesystem rejects invalid magic", "[filesystem][ext2][filesystem
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 2 * block_size);
     REQUIRE(device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
 
     THEN("mount fails with invalid_magic_number")
     {
-      REQUIRE(fs->mount(dev_inode).error() == kernel::filesystem::ext2::ext2_errc::invalid_magic_number);
+      REQUIRE(fs->mount(dev_inode).error() == kernel::filesystems::ext2::errc::invalid_magic_number);
     }
   }
 }
@@ -207,37 +207,37 @@ SCENARIO("Ext2 block mapping includes direct and all indirect levels", "[filesys
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 128 * block_size);
     REQUIRE(device);
 
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
     auto mount = fs->mount(dev_inode);
     REQUIRE(mount);
-    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>(mount->second);
+    auto mount_state = static_pointer_cast<kernel::filesystems::ext2::mount_state>(mount->second);
     REQUIRE(mount_state);
 
-    auto inode_data = kernel::filesystem::ext2::inode_data{};
+    auto inode_data = kernel::filesystems::ext2::inode_data{};
     inode_data.block[0] = 7;
 
     inode_data.block[12] = 30;
-    kernel::tests::filesystem::ext2::write_u32(*device, 30 * block_size, 31);
+    kernel::tests::filesystems::ext2::write_u32(*device, 30 * block_size, 31);
 
     inode_data.block[13] = 40;
-    kernel::tests::filesystem::ext2::write_u32(*device, 40 * block_size, 41);
-    kernel::tests::filesystem::ext2::write_u32(*device, 41 * block_size, 42);
+    kernel::tests::filesystems::ext2::write_u32(*device, 40 * block_size, 41);
+    kernel::tests::filesystems::ext2::write_u32(*device, 41 * block_size, 42);
 
     inode_data.block[14] = 50;
-    kernel::tests::filesystem::ext2::write_u32(*device, 50 * block_size, 51);
-    kernel::tests::filesystem::ext2::write_u32(*device, 51 * block_size, 52);
-    kernel::tests::filesystem::ext2::write_u32(*device, 52 * block_size, 53);
+    kernel::tests::filesystems::ext2::write_u32(*device, 50 * block_size, 51);
+    kernel::tests::filesystems::ext2::write_u32(*device, 51 * block_size, 52);
+    kernel::tests::filesystems::ext2::write_u32(*device, 52 * block_size, 53);
 
     auto const numbers_per_block = static_cast<uint32_t>(block_size / kstd::size_of<uint32_t>());
-    auto const singly_start = static_cast<uint32_t>(kernel::filesystem::ext2::constants::direct_block_count);
+    auto const singly_start = static_cast<uint32_t>(kernel::filesystems::ext2::constants::direct_block_count);
     auto const doubly_start = singly_start + numbers_per_block;
     auto const triply_start = doubly_start + numbers_per_block * numbers_per_block;
 
-    auto inode = kernel::filesystem::ext2::inode{42, inode_data};
+    auto inode = kernel::filesystems::ext2::inode{42, inode_data};
 
     THEN("mapping resolves direct, singly, doubly and triply indirect indexes")
     {
@@ -264,17 +264,17 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 256 * block_size);
     REQUIRE(device);
 
-    auto superblock = kernel::filesystem::ext2::superblock{};
-    superblock.magic = kernel::filesystem::ext2::constants::magic_number;
+    auto superblock = kernel::filesystems::ext2::superblock{};
+    superblock.magic = kernel::filesystems::ext2::constants::magic_number;
     superblock.log_block_size = 0;
     superblock.blocks_count = 256;
     superblock.free_blocks_count = 128;
     superblock.blocks_per_group = 256;
     superblock.inodes_per_group = 32;
-    superblock.rev_level = kernel::filesystem::ext2::constants::dynamic_revision;
+    superblock.rev_level = kernel::filesystems::ext2::constants::dynamic_revision;
     superblock.inode_size = 128;
 
-    auto block_group_descriptor = kernel::filesystem::ext2::block_group_descriptor{};
+    auto block_group_descriptor = kernel::filesystems::ext2::block_group_descriptor{};
     block_group_descriptor.block_bitmap = 255;
     block_group_descriptor.inode_table = 5;
     block_group_descriptor.free_blocks_count = 128;
@@ -283,15 +283,15 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
     block_bitmap[0] = std::byte{0b1111'1111};
     block_bitmap[1] = std::byte{0b1111'1111};
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
     REQUIRE(dev_inode->write(block_bitmap, block_group_descriptor.block_bitmap * block_size));
 
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock, block_group_descriptor);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device, superblock, block_group_descriptor);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
     auto mount = fs->mount(dev_inode);
     REQUIRE(mount);
-    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>(mount->second);
+    auto mount_state = static_pointer_cast<kernel::filesystems::ext2::mount_state>(mount->second);
     REQUIRE(mount_state);
 
     auto read_u32 = [&](kstd::bytes offset) -> uint32_t {
@@ -300,10 +300,10 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
       return value;
     };
 
-    auto inode_data = kernel::filesystem::ext2::inode_data{};
+    auto inode_data = kernel::filesystems::ext2::inode_data{};
 
     auto const numbers_per_block = static_cast<uint32_t>(block_size / kstd::size_of<uint32_t>());
-    auto const singly_start = static_cast<uint32_t>(kernel::filesystem::ext2::constants::direct_block_count);
+    auto const singly_start = static_cast<uint32_t>(kernel::filesystems::ext2::constants::direct_block_count);
     auto const doubly_start = singly_start + numbers_per_block;
     auto const triply_start = doubly_start + numbers_per_block * numbers_per_block;
 
@@ -314,7 +314,7 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
       constexpr auto doubly_global_block_number = 303;
       constexpr auto triply_global_block_number = 404;
 
-      auto batch = kernel::filesystem::ext2::write_batch{*mount_state};
+      auto batch = kernel::filesystems::ext2::write_batch{*mount_state};
 
       REQUIRE(write_global_block_number_to_inode_block_index(0, inode_data, direct_global_block_number, *mount_state,
                                                              batch));
@@ -347,7 +347,7 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
       REQUIRE(triply_leaf_table == 21);
       REQUIRE(read_u32(static_cast<size_t>(triply_leaf_table) * block_size) == triply_global_block_number);
 
-      auto inode = kernel::filesystem::ext2::inode{42, inode_data};
+      auto inode = kernel::filesystems::ext2::inode{42, inode_data};
 
       REQUIRE(inode_block_number(0, inode, *mount_state) == direct_global_block_number);
       REQUIRE(inode_block_number(singly_start, inode, *mount_state) == singly_global_block_number);
diff --git a/kernel/kernel/filesystem/ext2/inode.cpp b/kernel/kernel/filesystems/ext2/inode.cpp
index c57ced93..8e5c4559 100644
--- a/kernel/kernel/filesystem/ext2/inode.cpp
+++ b/kernel/kernel/filesystems/ext2/inode.cpp
@@ -1,15 +1,15 @@
-#include <kernel/filesystem/ext2/inode.hpp>
-
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/ext2/directory_iterator.hpp>
-#include <kernel/filesystem/ext2/error.hpp>
-#include <kernel/filesystem/ext2/filesystem.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
-#include <kernel/filesystem/ext2/write_batch.hpp>
-#include <kernel/filesystem/inode.hpp>
-#include <kernel/filesystem/mount.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+
+#include <kernel/filesystems/ext2/directory_iterator.hpp>
+#include <kernel/filesystems/ext2/error.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/write_batch.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/inode.hpp>
+#include <kernel/vfs/mount.hpp>
 
 #include <kapi/filesystem.hpp>
 #include <kapi/system.hpp>
@@ -30,7 +30,7 @@
 
 using namespace kstd::units_literals;
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
   namespace
@@ -84,7 +84,7 @@ namespace kernel::filesystem::ext2
     auto backing_inode = (*state)->backing_inode;
     if (!(*state)->backing_inode)
     {
-      return kstd::failure(vfs_errc::not_mounted);
+      return kstd::failure(vfs::errc::not_mounted);
     }
 
     auto guard = kstd::lock_guard{(*state)->lock};
@@ -110,7 +110,7 @@ namespace kernel::filesystem::ext2
     auto backing_inode = (*state)->backing_inode;
     if (!(*state)->backing_inode)
     {
-      return kstd::failure(vfs_errc::not_mounted);
+      return kstd::failure(vfs::errc::not_mounted);
     }
 
     auto guard = kstd::lock_guard{(*state)->lock};
@@ -129,7 +129,7 @@ namespace kernel::filesystem::ext2
 
       if (!append_blocks(additional_blocks_needed, batch))
       {
-        return kstd::failure(ext2_errc::not_enough_free_blocks);
+        return kstd::failure(errc::not_enough_free_blocks);
       }
     }
 
@@ -212,7 +212,7 @@ namespace kernel::filesystem::ext2
 
   auto inode::status() const -> kstd::result<kapi::filesystem::file_status>
   {
-    auto result = kernel::filesystem::inode::status();
+    auto result = kernel::vfs::inode::status();
     if (!result)
     {
       return result;
@@ -226,12 +226,13 @@ namespace kernel::filesystem::ext2
     return result;
   }
 
-  auto inode::read_directory(directory_listing_cursor position, std::span<directory_listing_entry> entries) const
-      -> kstd::result<std::pair<std::size_t, directory_listing_cursor>>
+  auto inode::read_directory(vfs::directory_listing_cursor position,
+                             std::span<vfs::directory_listing_entry> entries) const
+      -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>>
   {
     if (!is_directory())
     {
-      return kstd::failure(vfs_errc::not_a_directory);
+      return kstd::failure(vfs::errc::not_a_directory);
     }
 
     auto state = get_driver_data();
@@ -252,7 +253,7 @@ namespace kernel::filesystem::ext2
         continue;
       }
 
-      entries[count++] = directory_listing_entry{
+      entries[count++] = vfs::directory_listing_entry{
         .name = kstd::string{it->name()},
         .type = to_file_type(it->file_type),
         .inode_number = it->inode,
@@ -264,7 +265,7 @@ namespace kernel::filesystem::ext2
       }
     }
 
-    return std::pair{count, directory_listing_cursor{it.offset().value}};
+    return std::pair{count, vfs::directory_listing_cursor{it.offset().value}};
   }
 
   auto inode::append_blocks(size_t count, write_batch & batch) -> bool
@@ -345,7 +346,7 @@ namespace kernel::filesystem::ext2
       return static_pointer_cast<mount_state>(mount->driver_data());
     }
 
-    return kstd::failure(vfs_errc::not_mounted);
+    return kstd::failure(vfs::errc::not_mounted);
   }
 
   auto inode::get_driver_data() const -> kstd::result<kstd::shared_ptr<mount_state const>>
@@ -355,7 +356,7 @@ namespace kernel::filesystem::ext2
       return static_pointer_cast<mount_state const>(mount->driver_data());
     }
 
-    return kstd::failure(vfs_errc::not_mounted);
+    return kstd::failure(vfs::errc::not_mounted);
   }
 
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
diff --git a/kernel/kernel/filesystem/ext2/inode.hpp b/kernel/kernel/filesystems/ext2/inode.hpp
index 77164e28..e2cb74a1 100644
--- a/kernel/kernel/filesystem/ext2/inode.hpp
+++ b/kernel/kernel/filesystems/ext2/inode.hpp
@@ -1,11 +1,11 @@
 #ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_INODE_HPP
 #define TEACHOS_KERNEL_FILESYSTEM_EXT2_INODE_HPP
 
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
-#include <kernel/filesystem/ext2/write_batch.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/write_batch.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -20,7 +20,7 @@
 #include <span>
 #include <utility>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
   struct filesystem;
 
@@ -47,7 +47,7 @@ namespace kernel::filesystem::ext2
     std::array<uint8_t, 12> osd2;  // NOLINT(readability-magic-numbers)
   };
 
-  struct inode : kernel::filesystem::inode
+  struct inode : kernel::vfs::inode
   {
     //! @name Construction/Destruction
     //! @{
@@ -92,9 +92,9 @@ namespace kernel::filesystem::ext2
 
     [[nodiscard]] auto status() const -> kstd::result<kapi::filesystem::file_status> override;
 
-    [[nodiscard]] auto read_directory(directory_listing_cursor position,
-                                      std::span<directory_listing_entry> entries) const
-        -> kstd::result<std::pair<std::size_t, directory_listing_cursor>> override;
+    [[nodiscard]] auto read_directory(vfs::directory_listing_cursor position,
+                                      std::span<vfs::directory_listing_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>> override;
 
     //! @}
 
@@ -156,6 +156,6 @@ namespace kernel::filesystem::ext2
     //! The inode data.
     inode_data m_data{};
   };
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/ext2/inode.tests.cpp b/kernel/kernel/filesystems/ext2/inode.tests.cpp
index 6b6525bc..aa8a8da5 100644
--- a/kernel/kernel/filesystem/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystems/ext2/inode.tests.cpp
@@ -1,20 +1,20 @@
-#include <kernel/filesystem/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
 
 #include <kernel/devices/storage.hpp>
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/ext2/block_group_descriptor.hpp>
-#include <kernel/filesystem/ext2/filesystem.hpp>
-#include <kernel/filesystem/ext2/linked_directory_entry.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
-#include <kernel/filesystem/ext2/superblock.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/mount.hpp>
+#include <kernel/filesystems/ext2/block_group_descriptor.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
+#include <kernel/filesystems/ext2/linked_directory_entry.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/superblock.hpp>
 #include <kernel/test_support/cpu.hpp>
 #include <kernel/test_support/devices/block_device.hpp>
-#include <kernel/test_support/filesystem/ext2.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
+#include <kernel/test_support/filesystems/ext2.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
+#include <kernel/vfs/device_inode.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/mount.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -48,7 +48,7 @@ namespace
     auto const rounded = (header_and_name + 3uz) & ~3uz;
     auto const rec_len = extend_to_block_end ? static_cast<std::size_t>(block_size.value) - offset : rounded;
 
-    auto * entry = reinterpret_cast<kernel::filesystem::ext2::linked_directory_entry *>(block.data() + offset);
+    auto * entry = reinterpret_cast<kernel::filesystems::ext2::linked_directory_entry *>(block.data() + offset);
     entry->inode = inode_number;
     entry->rec_len = static_cast<uint16_t>(rec_len);
     entry->name_len = static_cast<uint8_t>(name.size());
@@ -63,13 +63,13 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]"
 {
   GIVEN("an ext2 filesystem")
   {
-    auto fs = kernel::filesystem::ext2::filesystem{};
-    auto data = kernel::filesystem::ext2::inode_data{};
+    auto fs = kernel::filesystems::ext2::filesystem{};
+    auto data = kernel::filesystems::ext2::inode_data{};
 
     THEN("the inode is initialized with regular file mode in data and has the kind regular")
     {
-      data.mode = kernel::filesystem::ext2::constants::mode_regular;
-      auto inode = kernel::filesystem::ext2::inode(42, data);
+      data.mode = kernel::filesystems::ext2::constants::mode_regular;
+      auto inode = kernel::filesystems::ext2::inode(42, data);
 
       REQUIRE(inode.is_regular());
       REQUIRE_FALSE(inode.is_directory());
@@ -79,8 +79,8 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]"
 
     THEN("the inode is initialized with directory mode in data and has the kind directory")
     {
-      data.mode = kernel::filesystem::ext2::constants::mode_directory;
-      auto inode = kernel::filesystem::ext2::inode(42, data);
+      data.mode = kernel::filesystems::ext2::constants::mode_directory;
+      auto inode = kernel::filesystems::ext2::inode(42, data);
 
       REQUIRE_FALSE(inode.is_regular());
       REQUIRE(inode.is_directory());
@@ -90,8 +90,8 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]"
 
     THEN("the inode is initialized with symbolic link mode in data and has the kind symbolic link")
     {
-      data.mode = kernel::filesystem::ext2::constants::mode_symbolic_link;
-      auto inode = kernel::filesystem::ext2::inode(42, data);
+      data.mode = kernel::filesystems::ext2::constants::mode_symbolic_link;
+      auto inode = kernel::filesystems::ext2::inode(42, data);
 
       REQUIRE_FALSE(inode.is_regular());
       REQUIRE_FALSE(inode.is_directory());
@@ -102,7 +102,7 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]"
     THEN("the inode is initialized with zero mode in data and has no specific kind")
     {
       data.mode = 0;
-      auto inode = kernel::filesystem::ext2::inode(42, data);
+      auto inode = kernel::filesystems::ext2::inode(42, data);
 
       REQUIRE_FALSE(inode.is_regular());
       REQUIRE_FALSE(inode.is_directory());
@@ -112,7 +112,7 @@ SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]"
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 inode reads from real image",
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture, "Ext2 inode reads from real image",
                 "[filesystem][ext2][inode][img]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
@@ -125,10 +125,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
     auto boot_device = kernel::devices::storage::determine_boot_device();
     REQUIRE(boot_device != nullptr);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(boot_device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
@@ -172,25 +172,25 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     REQUIRE(mount);
 
-    auto data = kernel::filesystem::ext2::inode_data{};
+    auto data = kernel::filesystems::ext2::inode_data{};
     data.block[0] = 30;
     data.block[1] = 0;
     data.block[2] = 31;
     data.size = block_size.value * 3;
 
-    kernel::tests::filesystem::ext2::write_bytes(*device, 30 * block_size, "Hello", 5_B);
-    kernel::tests::filesystem::ext2::write_bytes(*device, 31 * block_size, "World!", 6_B);
+    kernel::tests::filesystems::ext2::write_bytes(*device, 30 * block_size, "Hello", 5_B);
+    kernel::tests::filesystems::ext2::write_bytes(*device, 31 * block_size, "World!", 6_B);
 
-    auto inode = kernel::filesystem::ext2::inode{42, data};
+    auto inode = kernel::filesystems::ext2::inode{42, data};
     inode.set_owning_mount(*mount);
 
     auto buffer = kstd::vector<std::byte>(data.size, std::byte{0xAB});
@@ -213,29 +213,29 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     REQUIRE(mount);
 
-    auto data = kernel::filesystem::ext2::inode_data{};
+    auto data = kernel::filesystems::ext2::inode_data{};
     data.block[0] = 30;
     data.block[12] = 31;
     data.size = block_size.value * 15;
 
-    kernel::tests::filesystem::ext2::write_u32(*device, 31 * block_size, 50);
-    kernel::tests::filesystem::ext2::write_u32(*device, 31 * block_size + 4_B, 0);
-    kernel::tests::filesystem::ext2::write_u32(*device, 31 * block_size + 8_B, 51);
+    kernel::tests::filesystems::ext2::write_u32(*device, 31 * block_size, 50);
+    kernel::tests::filesystems::ext2::write_u32(*device, 31 * block_size + 4_B, 0);
+    kernel::tests::filesystems::ext2::write_u32(*device, 31 * block_size + 8_B, 51);
 
-    kernel::tests::filesystem::ext2::write_bytes(*device, 30 * block_size, "Hello", 5_B);
-    kernel::tests::filesystem::ext2::write_bytes(*device, 50 * block_size, "Blub", 4_B);
-    kernel::tests::filesystem::ext2::write_bytes(*device, 51 * block_size, "World!", 6_B);
+    kernel::tests::filesystems::ext2::write_bytes(*device, 30 * block_size, "Hello", 5_B);
+    kernel::tests::filesystems::ext2::write_bytes(*device, 50 * block_size, "Blub", 4_B);
+    kernel::tests::filesystems::ext2::write_bytes(*device, 51 * block_size, "World!", 6_B);
 
-    auto inode = kernel::filesystem::ext2::inode{42, data};
+    auto inode = kernel::filesystems::ext2::inode{42, data};
     inode.set_owning_mount(*mount);
 
     auto buffer = kstd::vector<std::byte>(data.size, std::byte{0xAB});
@@ -261,20 +261,20 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     REQUIRE(mount);
 
-    auto data = kernel::filesystem::ext2::inode_data{};
+    auto data = kernel::filesystems::ext2::inode_data{};
     data.block[12] = 0;
     data.size = block_size.value * 15;
 
-    auto inode = kernel::filesystem::ext2::inode{42, data};
+    auto inode = kernel::filesystems::ext2::inode{42, data};
     inode.set_owning_mount(*mount);
 
     auto buffer = kstd::vector<std::byte>(block_size.value * 15, std::byte{0xAB});
@@ -295,22 +295,22 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     REQUIRE(mount);
 
-    auto inode_data = kernel::filesystem::ext2::inode_data{};
+    auto inode_data = kernel::filesystems::ext2::inode_data{};
     inode_data.size = block_size.value * 2;
     inode_data.block[0] = 20;
-    kernel::tests::filesystem::ext2::write_bytes(*device, 21 * block_size - 6_B, "Hello ", 6_B);
+    kernel::tests::filesystems::ext2::write_bytes(*device, 21 * block_size - 6_B, "Hello ", 6_B);
     inode_data.block[1] = 21;
-    kernel::tests::filesystem::ext2::write_bytes(*device, 21 * block_size, "World!", 6_B);
-    auto inode = kernel::filesystem::ext2::inode{42, inode_data};
+    kernel::tests::filesystems::ext2::write_bytes(*device, 21 * block_size, "World!", 6_B);
+    auto inode = kernel::filesystems::ext2::inode{42, inode_data};
     inode.set_owning_mount(*mount);
 
     auto buffer = kstd::vector<std::byte>(12, std::byte{0x00});
@@ -326,7 +326,7 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]")
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 inode writes to real image",
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture, "Ext2 inode writes to real image",
                 "[filesystem][ext2][inode]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
@@ -338,10 +338,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
     auto boot_device = kernel::devices::storage::determine_boot_device();
     REQUIRE(boot_device != nullptr);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(boot_device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
@@ -355,7 +355,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
     REQUIRE(file.value()->is_regular());
     (*file)->set_owning_mount(*mount);
 
-    auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>(driver_data);
+    auto mount_state = static_pointer_cast<kernel::filesystems::ext2::mount_state>(driver_data);
     REQUIRE(mount_state);
 
     THEN("writing to the inode updates backing device and the inode size")
@@ -374,15 +374,15 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
       auto const text = std::string_view{reinterpret_cast<char const *>(read_buffer.data()), bytes_read->value};
       REQUIRE(text == "Hello World!");
 
-      auto inode_data = static_cast<kernel::filesystem::ext2::inode *>(file.value().get())->data();
+      auto inode_data = static_cast<kernel::filesystems::ext2::inode *>(file.value().get())->data();
       REQUIRE(inode_data.size == bytes_read->value);
     }
 
     THEN("writing allocates new blocks and updates the inode size")
     {
-      auto inode = static_pointer_cast<kernel::filesystem::ext2::inode>(file.value());
+      auto inode = static_pointer_cast<kernel::filesystems::ext2::inode>(file.value());
 
-      auto const block_size = kernel::filesystem::ext2::block_size(*mount_state);
+      auto const block_size = kernel::filesystems::ext2::block_size(*mount_state);
       auto const expected_allocated_blocks = 32 * block_count(*inode, *mount_state);
 
       auto write_buffer = kstd::vector<std::byte>(block_size.value * expected_allocated_blocks, std::byte{'A'});
@@ -414,8 +414,8 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
   auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 128 * block_size);
   REQUIRE(device != nullptr);
 
-  auto superblock = kernel::filesystem::ext2::superblock{};
-  superblock.magic = kernel::filesystem::ext2::constants::magic_number;
+  auto superblock = kernel::filesystems::ext2::superblock{};
+  superblock.magic = kernel::filesystems::ext2::constants::magic_number;
   superblock.log_block_size = 0;
   superblock.blocks_count = 64;
   superblock.blocks_per_group = 64;
@@ -424,14 +424,14 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
   superblock.rev_level = 1;
   superblock.free_blocks_count = 64 - 15;
 
-  auto block_group_descriptor = kernel::filesystem::ext2::block_group_descriptor{};
+  auto block_group_descriptor = kernel::filesystems::ext2::block_group_descriptor{};
   block_group_descriptor.inode_table = 5;
   block_group_descriptor.free_blocks_count = 64 - 15;
   block_group_descriptor.block_bitmap = 10;
 
-  kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock, block_group_descriptor);
+  kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device, superblock, block_group_descriptor);
 
-  auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+  auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
   auto block_bitmap = std::vector<std::byte>(block_size.value, std::byte{0x00});
   block_bitmap[0] = std::byte{0b1111'1111};
@@ -440,25 +440,25 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
 
   REQUIRE(dev_inode->write(block_bitmap, block_group_descriptor.block_bitmap * block_size));
 
-  auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-  auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+  auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+  auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
   auto root = (*mount)->root_dentry()->inode();
   REQUIRE(mount);
-  auto mount_state = static_pointer_cast<kernel::filesystem::ext2::mount_state>((*mount)->driver_data());
+  auto mount_state = static_pointer_cast<kernel::filesystems::ext2::mount_state>((*mount)->driver_data());
   REQUIRE(mount_state);
 
-  auto inode_data = kernel::filesystem::ext2::inode_data{};
+  auto inode_data = kernel::filesystems::ext2::inode_data{};
   inode_data.size = 5;
   inode_data.blocks = 2 * block_size.value / 512;
   inode_data.block[0] = 20;
   inode_data.block[1] = 21;
-  inode_data.mode = kernel::filesystem::ext2::constants::mode_regular;
+  inode_data.mode = kernel::filesystems::ext2::constants::mode_regular;
 
   uint32_t inode_number = 3;
   auto const inode_data_offset = block_group_descriptor.inode_table * block_size +
                                  kstd::bytes{(inode_number - 1) * mount_state->superblock.inode_size};
 
-  auto inode = kernel::filesystem::ext2::inode{inode_number, inode_data};
+  auto inode = kernel::filesystems::ext2::inode{inode_number, inode_data};
   inode.set_owning_mount(*mount);
   REQUIRE(dev_inode->write(kstd::raw_bytes(inode), inode_data_offset));
 
@@ -469,9 +469,9 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
   GIVEN("mocked ext2 filesystem")
   {
     auto do_read_inode = [&]() {
-      auto inode_data = kernel::filesystem::ext2::inode_data{};
+      auto inode_data = kernel::filesystems::ext2::inode_data{};
       REQUIRE(dev_inode->read(kstd::raw_bytes(inode_data), inode_data_offset));
-      auto read_inode = kernel::filesystem::ext2::inode{inode_number, inode_data};
+      auto read_inode = kernel::filesystems::ext2::inode{inode_number, inode_data};
       read_inode.set_owning_mount(*mount);
       return read_inode;
     };
@@ -563,8 +563,8 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
 {
   auto const block_size = 1024_B;
 
-  auto superblock = kernel::filesystem::ext2::superblock{};
-  superblock.magic = kernel::filesystem::ext2::constants::magic_number;
+  auto superblock = kernel::filesystems::ext2::superblock{};
+  superblock.magic = kernel::filesystems::ext2::constants::magic_number;
   superblock.log_block_size = 0;
   superblock.blocks_count = 64;
   superblock.blocks_per_group = 64;
@@ -577,16 +577,16 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
 
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device, superblock);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     REQUIRE(mount);
 
-    auto data = kernel::filesystem::ext2::inode_data{};
+    auto data = kernel::filesystems::ext2::inode_data{};
     data.size = 256;
     data.dir_acl = 32;
 
@@ -594,7 +594,7 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
                                               uint32_t expected_dir_acl_after_set_size) {
       data.mode = mode;
 
-      auto inode = kernel::filesystem::ext2::inode{42, data};
+      auto inode = kernel::filesystems::ext2::inode{42, data};
       inode.set_owning_mount(*mount);
 
       REQUIRE(inode.size() == expected_initial_size);
@@ -608,12 +608,12 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
 
     THEN("the inode size is 256 if mode = regular")
     {
-      verify_size_and_set_size(kernel::filesystem::ext2::constants::mode_regular, 256_B, 32);
+      verify_size_and_set_size(kernel::filesystems::ext2::constants::mode_regular, 256_B, 32);
     }
 
     THEN("the inode size is 256 if mode = directory")
     {
-      verify_size_and_set_size(kernel::filesystem::ext2::constants::mode_directory, 256_B, 32);
+      verify_size_and_set_size(kernel::filesystems::ext2::constants::mode_directory, 256_B, 32);
     }
   }
 
@@ -623,16 +623,16 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
 
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device, superblock);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     REQUIRE(mount);
 
-    auto data = kernel::filesystem::ext2::inode_data{};
+    auto data = kernel::filesystems::ext2::inode_data{};
     data.size = 256;
     data.dir_acl = 32;
 
@@ -640,7 +640,7 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
                                               uint32_t expected_dir_acl_after_set_size) {
       data.mode = mode;
 
-      auto inode = kernel::filesystem::ext2::inode{42, data};
+      auto inode = kernel::filesystems::ext2::inode{42, data};
       inode.set_owning_mount(*mount);
 
       REQUIRE(inode.size() == expected_initial_size);
@@ -654,12 +654,12 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
 
     THEN("the inode size is 256 if mode = regular")
     {
-      verify_size_and_set_size(kernel::filesystem::ext2::constants::mode_regular, 0x0000'0020'0000'0100_B, 0);
+      verify_size_and_set_size(kernel::filesystems::ext2::constants::mode_regular, 0x0000'0020'0000'0100_B, 0);
     }
 
     THEN("the inode size is 256 if mode = directory")
     {
-      verify_size_and_set_size(kernel::filesystem::ext2::constants::mode_directory, 256_B, 32);
+      verify_size_and_set_size(kernel::filesystems::ext2::constants::mode_directory, 256_B, 32);
     }
   }
 }
@@ -668,13 +668,13 @@ SCENARIO("Ext2 inode status()", "[filesystem][ext2][inode]")
 {
   GIVEN("an ext block device inode with real metadata")
   {
-    auto fs = kernel::filesystem::ext2::filesystem{};
-    auto data = kernel::filesystem::ext2::inode_data{};
-    data.mode = kernel::filesystem::ext2::constants::mode_block_device;
+    auto fs = kernel::filesystems::ext2::filesystem{};
+    auto data = kernel::filesystems::ext2::inode_data{};
+    data.mode = kernel::filesystems::ext2::constants::mode_block_device;
     data.block[0] = (1 << 8);
     data.links_count = 1;
 
-    auto inode = kernel::filesystem::ext2::inode(42, data);
+    auto inode = kernel::filesystems::ext2::inode(42, data);
 
     THEN("status() reports the real inode number, link count, and decoded raw device")
     {
@@ -689,7 +689,7 @@ SCENARIO("Ext2 inode status()", "[filesystem][ext2][inode]")
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture,
                 "Ext2 inode read_directory returns real directory entries", "[filesystem][ext2][inode][img][readdir]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
@@ -702,10 +702,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
     auto boot_device = kernel::devices::storage::determine_boot_device();
     REQUIRE(boot_device != nullptr);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(boot_device);
 
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     auto root = (*mount)->root_dentry()->inode();
     auto driver_data = (*mount)->driver_data();
     REQUIRE(mount);
@@ -716,8 +716,8 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
 
     WHEN("read_directory is called with a buffer large enough for everything in it")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>(8);
-      auto result = (*information)->read_directory(kernel::filesystem::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(8);
+      auto result = (*information)->read_directory(kernel::vfs::directory_listing_cursor{}, entries);
 
       THEN("known entries come back, correctly typed")
       {
@@ -755,14 +755,14 @@ SCENARIO("Ext2 inode read_directory rejects non-directory inodes", "[filesystem]
 {
   GIVEN("a regular file inode")
   {
-    auto data = kernel::filesystem::ext2::inode_data{};
-    data.mode = kernel::filesystem::ext2::constants::mode_regular;
-    auto inode = kernel::filesystem::ext2::inode{7, data};
+    auto data = kernel::filesystems::ext2::inode_data{};
+    data.mode = kernel::filesystems::ext2::constants::mode_regular;
+    auto inode = kernel::filesystems::ext2::inode{7, data};
 
     THEN("read_directory fails without needing a mount at all")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
-      auto result = inode.read_directory(kernel::filesystem::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+      auto result = inode.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
 
       REQUIRE_FALSE(result);
     }
@@ -779,8 +779,8 @@ SCENARIO("Ext2 inode read_directory skips deleted entries and paginates correctl
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("mock", block_size, 64 * block_size);
     REQUIRE(device != nullptr);
 
-    auto superblock = kernel::filesystem::ext2::superblock{};
-    superblock.magic = kernel::filesystem::ext2::constants::magic_number;
+    auto superblock = kernel::filesystems::ext2::superblock{};
+    superblock.magic = kernel::filesystems::ext2::constants::magic_number;
     superblock.log_block_size = 0;
     superblock.blocks_count = 64;
     superblock.blocks_per_group = 64;
@@ -788,47 +788,47 @@ SCENARIO("Ext2 inode read_directory skips deleted entries and paginates correctl
     superblock.inode_size = 128;
     superblock.rev_level = 1;
 
-    auto block_group_descriptor = kernel::filesystem::ext2::block_group_descriptor{};
+    auto block_group_descriptor = kernel::filesystems::ext2::block_group_descriptor{};
     block_group_descriptor.inode_table = 5;
     block_group_descriptor.block_bitmap = 10;
 
-    kernel::tests::filesystem::ext2::setup_mock_ext2_layout(*device, superblock, block_group_descriptor);
+    kernel::tests::filesystems::ext2::setup_mock_ext2_layout(*device, superblock, block_group_descriptor);
 
-    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
-    auto fs = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
-    auto mount = kernel::filesystem::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
+    auto dev_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
+    auto fs = kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    auto mount = kernel::vfs::mount::create(nullptr, fs, nullptr, nullptr, dev_inode);
     REQUIRE(mount);
 
     auto block = std::vector<std::byte>(block_size.value, std::byte{0});
     auto offset = 0uz;
     offset +=
         write_entry(block, offset, 10, "alpha",
-                    static_cast<uint8_t>(kernel::filesystem::ext2::constants::mode_regular >> 8), block_size, false);
+                    static_cast<uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8), block_size, false);
     offset += write_entry(block, offset, 0, "deleted", 0, block_size, false);
     offset +=
         write_entry(block, offset, 11, "beta",
-                    static_cast<uint8_t>(kernel::filesystem::ext2::constants::mode_regular >> 8), block_size, false);
+                    static_cast<uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8), block_size, false);
     write_entry(block, offset, 12, "gamma",
-                static_cast<uint8_t>(kernel::filesystem::ext2::constants::mode_regular >> 8), block_size, true);
+                static_cast<uint8_t>(kernel::filesystems::ext2::constants::mode_regular >> 8), block_size, true);
 
-    kernel::tests::filesystem::ext2::write_bytes(*device, 30 * block_size, block.data(), block_size);
+    kernel::tests::filesystems::ext2::write_bytes(*device, 30 * block_size, block.data(), block_size);
 
-    auto data = kernel::filesystem::ext2::inode_data{};
-    data.mode = kernel::filesystem::ext2::constants::mode_directory;
+    auto data = kernel::filesystems::ext2::inode_data{};
+    data.mode = kernel::filesystems::ext2::constants::mode_directory;
     data.size = block_size.value;
     data.block[0] = 30;
 
-    auto directory = kernel::filesystem::ext2::inode{3, data};
+    auto directory = kernel::filesystems::ext2::inode{3, data};
     directory.set_owning_mount(*mount);
 
     WHEN("read_directory is called one entry at a time, chaining the returned cursor")
     {
       auto seen = std::vector<std::string>{};
-      auto position = kernel::filesystem::directory_listing_cursor{};
+      auto position = kernel::vfs::directory_listing_cursor{};
 
       for (auto guard = 0; guard < 8; ++guard)
       {
-        auto one = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
+        auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
         auto result = directory.read_directory(position, one);
         REQUIRE(result);
         auto [count, next] = *result;
@@ -852,8 +852,8 @@ SCENARIO("Ext2 inode read_directory skips deleted entries and paginates correctl
 
     WHEN("read_directory is called with a buffer that exactly fits the three real entries")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>(3);
-      auto result = directory.read_directory(kernel::filesystem::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(3);
+      auto result = directory.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
 
       THEN("all three come back, and the very next call reports exhaustion, not a fourth entry")
       {
diff --git a/kernel/kernel/filesystem/ext2/linked_directory_entry.hpp b/kernel/kernel/filesystems/ext2/linked_directory_entry.hpp
index 2d364f05..9530a586 100644
--- a/kernel/kernel/filesystem/ext2/linked_directory_entry.hpp
+++ b/kernel/kernel/filesystems/ext2/linked_directory_entry.hpp
@@ -1,10 +1,10 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_LINKED_DIRECTORY_ENTRY_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_LINKED_DIRECTORY_ENTRY_HPP
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_LINKED_DIRECTORY_ENTRY_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_LINKED_DIRECTORY_ENTRY_HPP
 
 #include <cstdint>
 #include <string_view>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
   //! A linked directory entry in the ext2 filesystem.
   struct [[gnu::packed]] linked_directory_entry
@@ -20,6 +20,6 @@ namespace kernel::filesystem::ext2
     uint8_t file_type;
     char name_start;  // NOLINT(readability-magic-numbers)
   };
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystems/ext2/module.cpp b/kernel/kernel/filesystems/ext2/module.cpp
new file mode 100644
index 00000000..9032109a
--- /dev/null
+++ b/kernel/kernel/filesystems/ext2/module.cpp
@@ -0,0 +1,26 @@
+#include <kernel/filesystems/ext2/filesystem.hpp>
+#include <kernel/vfs/driver_registry.hpp>
+#include <kernel/vfs/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+
+#include <string_view>
+
+namespace
+{
+  struct descriptor final : kernel::vfs::driver_descriptor
+  {
+    [[nodiscard]] auto name() const noexcept -> std::string_view override
+    {
+      return "ext2";
+    }
+
+    [[nodiscard]] auto make_instance() const -> kernel::vfs::filesystem::filesystem_ptr override
+    {
+      return kstd::make_shared<kernel::filesystems::ext2::filesystem>();
+    }
+  };
+
+  [[gnu::used]]
+  constexpr auto registration = kernel::vfs::driver_module<descriptor>{};
+}  // namespace
diff --git a/kernel/kernel/filesystems/ext2/mount_state.hpp b/kernel/kernel/filesystems/ext2/mount_state.hpp
new file mode 100644
index 00000000..8103f4fb
--- /dev/null
+++ b/kernel/kernel/filesystems/ext2/mount_state.hpp
@@ -0,0 +1,26 @@
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_MOUNT_STATE_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_MOUNT_STATE_HPP
+
+#include <kernel/filesystems/ext2/block_group_descriptor.hpp>
+#include <kernel/filesystems/ext2/superblock.hpp>
+#include <kernel/vfs/inode.hpp>
+
+#include <kapi/tracked_mutex.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/vector.hpp>
+
+namespace kernel::filesystems::ext2
+{
+
+  struct mount_state
+  {
+    struct superblock superblock{};
+    kstd::vector<block_group_descriptor> block_group_descriptors{};
+    kstd::shared_ptr<kernel::vfs::inode> backing_inode{};
+    mutable kapi::tracked_mutex lock{};
+  };
+
+}  // namespace kernel::filesystems::ext2
+
+#endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/ext2/superblock.hpp b/kernel/kernel/filesystems/ext2/superblock.hpp
index dce3cb29..92c73513 100644
--- a/kernel/kernel/filesystem/ext2/superblock.hpp
+++ b/kernel/kernel/filesystems/ext2/superblock.hpp
@@ -1,5 +1,5 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_SUPERBLOCK_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_SUPERBLOCK_HPP
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_SUPERBLOCK_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_SUPERBLOCK_HPP
 
 #include <kstd/bitfield_enum.hpp>
 
@@ -7,7 +7,7 @@
 #include <cstdint>
 #include <type_traits>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
   //! Ext2 compatible features.
@@ -107,15 +107,15 @@ namespace kernel::filesystem::ext2
     uint32_t first_meta_bg;
     std::array<uint8_t, 760> unused;  // NOLINT(readability-magic-numbers)
   };
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
 
 template<>
-struct kstd::is_bitfield_enum<kernel::filesystem::ext2::incompatible_features> : std::true_type
+struct kstd::is_bitfield_enum<kernel::filesystems::ext2::incompatible_features> : std::true_type
 {
 };
 
 template<>
-struct kstd::is_bitfield_enum<kernel::filesystem::ext2::read_only_compatible_features> : std::true_type
+struct kstd::is_bitfield_enum<kernel::filesystems::ext2::read_only_compatible_features> : std::true_type
 {
 };
 
diff --git a/kernel/kernel/filesystem/ext2/write_batch.cpp b/kernel/kernel/filesystems/ext2/write_batch.cpp
index 3ea6ef19..f9a86a82 100644
--- a/kernel/kernel/filesystem/ext2/write_batch.cpp
+++ b/kernel/kernel/filesystems/ext2/write_batch.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/ext2/write_batch.hpp>
+#include <kernel/filesystems/ext2/write_batch.hpp>
 
-#include <kernel/filesystem/ext2/filesystem.hpp>
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/mount_state.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/mount_state.hpp>
 
 #include <kapi/system.hpp>
 
@@ -10,7 +10,7 @@
 #include <cstddef>
 #include <ranges>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
   write_batch::write_batch(mount_state & state)
@@ -63,4 +63,4 @@ namespace kernel::filesystem::ext2
     }
   }
 
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
diff --git a/kernel/kernel/filesystem/ext2/write_batch.hpp b/kernel/kernel/filesystems/ext2/write_batch.hpp
index 110d089c..926936df 100644
--- a/kernel/kernel/filesystem/ext2/write_batch.hpp
+++ b/kernel/kernel/filesystems/ext2/write_batch.hpp
@@ -1,14 +1,13 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_EXT2_WRITE_BATCH_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_EXT2_WRITE_BATCH_HPP
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_EXT2_WRITE_BATCH_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_EXT2_WRITE_BATCH_HPP
 
 #include <kstd/vector.hpp>
 
 #include <cstddef>
 
-namespace kernel::filesystem::ext2
+namespace kernel::filesystems::ext2
 {
 
-  struct filesystem;
   struct inode;
   struct mount_state;
 
@@ -46,6 +45,6 @@ namespace kernel::filesystem::ext2
     kstd::vector<inode *> m_dirty_inodes{};
   };
 
-}  // namespace kernel::filesystem::ext2
+}  // namespace kernel::filesystems::ext2
 
 #endif
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.cpp b/kernel/kernel/filesystems/rootfs/filesystem.cpp
index 4618fd69..01dfddc1 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.cpp
+++ b/kernel/kernel/filesystems/rootfs/filesystem.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/rootfs/filesystem.hpp>
+#include <kernel/filesystems/rootfs/filesystem.hpp>
 
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/rootfs/inode.hpp>
+#include <kernel/filesystems/rootfs/inode.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/filesystem.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -14,15 +14,15 @@
 #include <optional>
 #include <string_view>
 
-namespace kernel::filesystem::rootfs
+namespace kernel::filesystems::rootfs
 {
-  static_assert(sizeof(kernel::filesystem::filesystem) == sizeof(rootfs::filesystem));
+  static_assert(sizeof(kernel::vfs::filesystem) == sizeof(rootfs::filesystem));
 
   auto filesystem::probe(inode_ptr const & inode) const -> kstd::result<std::uint32_t>
   {
     if (inode)
     {
-      return kstd::failure(vfs_errc::invalid_argument);
+      return kstd::failure(vfs::errc::invalid_argument);
     }
 
     return 0;
@@ -36,12 +36,12 @@ namespace kernel::filesystem::rootfs
 
   auto filesystem::lookup(inode_ptr const &, std::string_view, driver_data_ptr) const -> kstd::result<inode_ptr>
   {
-    return kstd::failure(vfs_errc::no_such_file_or_directory);
+    return kstd::failure(vfs::errc::no_such_file_or_directory);
   }
 
   auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type, driver_data_ptr,
                                 std::optional<kapi::filesystem::device_number>) -> kstd::result<inode_ptr>
   {
-    return kstd::failure(vfs_errc::read_only_file_system);
+    return kstd::failure(vfs::errc::read_only_file_system);
   }
-}  // namespace kernel::filesystem::rootfs
+}  // namespace kernel::filesystems::rootfs
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.hpp b/kernel/kernel/filesystems/rootfs/filesystem.hpp
index 0195b250..6f4db776 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.hpp
+++ b/kernel/kernel/filesystems/rootfs/filesystem.hpp
@@ -1,8 +1,8 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_ROOTFS_FILESYSTEM_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_ROOTFS_FILESYSTEM_HPP
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_ROOTFS_FILESYSTEM_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_ROOTFS_FILESYSTEM_HPP
 
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -16,32 +16,27 @@
 #include <optional>
 #include <string_view>
 
-namespace kernel::filesystem::rootfs
+namespace kernel::filesystems::rootfs
 {
   //! A filesystem for the filesystem root.
   //!
   //! This filesystem provides access to the root directory and its contents, which are typically populated by the init
   //! process during system startup. The rootfs filesystem serves as the top-level directory in the filesystem
   //! hierarchy. It is responsible for providing a stable and consistent interface to the root directory.
-  struct filesystem : kernel::filesystem::filesystem
+  struct filesystem : kernel::vfs::filesystem
   {
     [[nodiscard]] auto probe(inode_ptr const & inode) const -> kstd::result<std::uint32_t> override;
 
-    //! @copydoc kernel::filesystem::filesystem::mount
     auto mount(inode_ptr const & backing_inode) -> kstd::result<mount_result> override;
 
-    //! @copydoc kernel::filesystem::filesystem::lookup.
-    //! @return Always returns an error, as rootfs is always empty.
     [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) const
         -> kstd::result<inode_ptr> override;
 
-    //! @copydoc kernel::filesystem::filesystem::create_inode.
-    //! @return Always returns an error, as creating new inodes is not supported in rootfs.
     [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
                                     driver_data_ptr driver_data,
                                     std::optional<kapi::filesystem::device_number> raw_device = std::nullopt)
         -> kstd::result<inode_ptr> override;
   };
-}  // namespace kernel::filesystem::rootfs
+}  // namespace kernel::filesystems::rootfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.tests.cpp b/kernel/kernel/filesystems/rootfs/filesystem.tests.cpp
index 15c8e313..1cc4c10f 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.tests.cpp
+++ b/kernel/kernel/filesystems/rootfs/filesystem.tests.cpp
@@ -1,6 +1,6 @@
-#include <kernel/filesystem/rootfs/filesystem.hpp>
+#include <kernel/filesystems/rootfs/filesystem.hpp>
 
-#include <kernel/filesystem/filesystem.hpp>
+#include <kernel/vfs/filesystem.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -14,7 +14,7 @@ SCENARIO("Rootfs filesystem mount and lookup", "[filesystem][rootfs][filesystem]
 {
   GIVEN("a mounted rootfs filesystem")
   {
-    auto fs = kstd::make_shared<kernel::filesystem::rootfs::filesystem>();
+    auto fs = kstd::make_shared<kernel::filesystems::rootfs::filesystem>();
     auto mount = fs->mount(nullptr);
     REQUIRE(mount);
     auto [root, driver_data] = *mount;
diff --git a/kernel/kernel/filesystem/rootfs/inode.cpp b/kernel/kernel/filesystems/rootfs/inode.cpp
index f2751afc..4c5b5384 100644
--- a/kernel/kernel/filesystem/rootfs/inode.cpp
+++ b/kernel/kernel/filesystems/rootfs/inode.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/rootfs/inode.hpp>
+#include <kernel/filesystems/rootfs/inode.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kstd/result.hpp>
 #include <kstd/units.hpp>
@@ -11,7 +11,7 @@
 #include <span>
 #include <utility>
 
-namespace kernel::filesystem::rootfs
+namespace kernel::filesystems::rootfs
 {
   auto inode::read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes>
   {
@@ -28,9 +28,9 @@ namespace kernel::filesystem::rootfs
     return true;
   }
 
-  auto inode::read_directory(directory_listing_cursor position, std::span<directory_listing_entry>) const
-      -> kstd::result<std::pair<std::size_t, directory_listing_cursor>>
+  auto inode::read_directory(vfs::directory_listing_cursor position, std::span<vfs::directory_listing_entry>) const
+      -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>>
   {
     return std::pair{0, position};
   }
-}  // namespace kernel::filesystem::rootfs
+}  // namespace kernel::filesystems::rootfs
diff --git a/kernel/kernel/filesystems/rootfs/inode.hpp b/kernel/kernel/filesystems/rootfs/inode.hpp
new file mode 100644
index 00000000..37b2fc54
--- /dev/null
+++ b/kernel/kernel/filesystems/rootfs/inode.hpp
@@ -0,0 +1,36 @@
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_ROOTFS_INODE_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_ROOTFS_INODE_HPP
+
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/inode.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/result.hpp>
+#include <kstd/string.hpp>
+#include <kstd/units.hpp>
+#include <kstd/vector.hpp>
+
+#include <cstddef>
+#include <span>
+#include <utility>
+
+namespace kernel::filesystems::rootfs
+{
+  //! An inode in the rootfs filesystem.
+  struct inode : kernel::vfs::inode
+  {
+    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> override;
+
+    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
+
+    [[nodiscard]] auto is_directory() const -> bool override;
+
+    [[nodiscard]] auto read_directory(vfs::directory_listing_cursor position,
+                                      std::span<vfs::directory_listing_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>> override;
+  };
+}  // namespace kernel::filesystems::rootfs
+
+#endif
diff --git a/kernel/kernel/filesystem/rootfs/inode.tests.cpp b/kernel/kernel/filesystems/rootfs/inode.tests.cpp
index 560e7953..7e151d9f 100644
--- a/kernel/kernel/filesystem/rootfs/inode.tests.cpp
+++ b/kernel/kernel/filesystems/rootfs/inode.tests.cpp
@@ -1,4 +1,4 @@
-#include <kernel/filesystem/rootfs/inode.hpp>
+#include <kernel/filesystems/rootfs/inode.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/print.hpp>
@@ -15,7 +15,7 @@ SCENARIO("Rootfs inode read/write", "[filesystem][rootfs][inode]")
 {
   GIVEN("a rootfs inode")
   {
-    auto inode = kernel::filesystem::rootfs::inode{};
+    auto inode = kernel::filesystems::rootfs::inode{};
 
     WHEN("reading from the inode")
     {
diff --git a/kernel/kernel/filesystems/rootfs/module.cpp b/kernel/kernel/filesystems/rootfs/module.cpp
new file mode 100644
index 00000000..5975e9ba
--- /dev/null
+++ b/kernel/kernel/filesystems/rootfs/module.cpp
@@ -0,0 +1,28 @@
+#include <kernel/filesystems/rootfs/filesystem.hpp>
+#include <kernel/vfs/driver_registry.hpp>
+#include <kernel/vfs/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+
+#include <string_view>
+
+namespace
+{
+
+  struct descriptor final : kernel::vfs::driver_descriptor
+  {
+    [[nodiscard]] auto name() const noexcept -> std::string_view override
+    {
+      return "rootfs";
+    }
+
+    [[nodiscard]] auto make_instance() const -> kernel::vfs::filesystem::filesystem_ptr override
+    {
+      return kstd::make_shared<kernel::filesystems::rootfs::filesystem>();
+    }
+  };
+
+  [[gnu::used]]
+  constexpr auto registration = kernel::vfs::driver_module<descriptor>{};
+
+}  // namespace
\ No newline at end of file
diff --git a/kernel/kernel/main.cpp b/kernel/kernel/main.cpp
index f8322b31..fd5ac5f1 100644
--- a/kernel/kernel/main.cpp
+++ b/kernel/kernel/main.cpp
@@ -1,10 +1,8 @@
-#include "kernel/filesystem/driver_registry.hpp"
 #include <kernel/devices/init.hpp>
 #include <kernel/devices/storage.hpp>
 #include <kernel/drivers/init.hpp>
-#include <kernel/filesystem/open_file_table.hpp>
-#include <kernel/filesystem/vfs.hpp>
 #include <kernel/memory.hpp>
+#include <kernel/vfs.hpp>
 
 #include <kapi/boot_modules.hpp>
 #include <kapi/cio.hpp>
@@ -245,13 +243,13 @@ auto main() -> int
   kapi::boot_modules::init(*modules_bus);
   kstd::println("[OS] Boot modules attached.");
 
-  kernel::filesystem::open_file_table::init();
+  kernel::vfs::open_file_table::init();
   kstd::println("[OS] Global open file table initialized.");
 
-  kernel::filesystem::driver_registry::init();
+  kernel::vfs::driver_registry::init();
   kstd::println("[OS] Builtin filesystems registered.");
 
-  kernel::filesystem::vfs::init();
+  kernel::vfs::vfs::init();
   kstd::println("[OS] Virtual filesystem initialized.");
 
   // TODO BA-FS26 remove demo code?
diff --git a/kernel/kernel/test_support/filesystem/device_number_registry.hpp b/kernel/kernel/test_support/filesystem/device_number_registry.hpp
deleted file mode 100644
index 5722837f..00000000
--- a/kernel/kernel/test_support/filesystem/device_number_registry.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_DEVICE_NUMBER_REGISTRY_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_DEVICE_NUMBER_REGISTRY_HPP
-
-namespace kernel::tests::filesystem::device_number_registry
-{
-  auto deinit() -> void;
-}
-
-#endif
diff --git a/kernel/kernel/test_support/filesystem/driver_registry.hpp b/kernel/kernel/test_support/filesystem/driver_registry.hpp
deleted file mode 100644
index b91acd57..00000000
--- a/kernel/kernel/test_support/filesystem/driver_registry.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_DRIVER_REGISTRY_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_DRIVER_REGISTRY_HPP
-
-namespace kernel::tests::filesystem::driver_registry
-{
-  //! Deinitialize the FS type registry singleton.
-  auto deinit() -> void;
-}  // namespace kernel::tests::filesystem::driver_registry
-
-#endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/ext2.hpp b/kernel/kernel/test_support/filesystem/ext2.hpp
deleted file mode 100644
index a83bdd94..00000000
--- a/kernel/kernel/test_support/filesystem/ext2.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_EXT2_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_EXT2_HPP
-
-#include <kernel/filesystem/ext2/block_group_descriptor.hpp>
-#include <kernel/filesystem/ext2/superblock.hpp>
-#include <kernel/test_support/devices/block_device.hpp>
-
-#include <kstd/units.hpp>
-
-#include <cstdint>
-
-namespace kernel::tests::filesystem::ext2
-{
-  auto write_bytes(kernel::tests::devices::block_device & device, kstd::bytes offset, void const * source,
-                   kstd::bytes size) -> void;
-  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, uint32_t value) -> void;
-  auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device) -> void;
-  auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
-                              kernel::filesystem::ext2::superblock const & superblock) -> void;
-  auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
-                              kernel::filesystem::ext2::superblock const & superblock,
-                              kernel::filesystem::ext2::block_group_descriptor const & group_descriptor) -> void;
-
-}  // namespace kernel::tests::filesystem::ext2
-
-#endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/open_file_table.hpp b/kernel/kernel/test_support/filesystem/open_file_table.hpp
deleted file mode 100644
index 46b03341..00000000
--- a/kernel/kernel/test_support/filesystem/open_file_table.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_OPEN_FILE_TABLE_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_OPEN_FILE_TABLE_HPP
-
-namespace kernel::tests::filesystem::open_file_table
-{
-  //! Deinitialize the open file table singleton.
-  auto deinit() -> void;
-}  // namespace kernel::tests::filesystem::open_file_table
-
-#endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/ext2.cpp b/kernel/kernel/test_support/filesystems/ext2.cpp
index 96d94ea1..d9008ade 100644
--- a/kernel/kernel/test_support/filesystem/ext2.cpp
+++ b/kernel/kernel/test_support/filesystems/ext2.cpp
@@ -1,9 +1,9 @@
-#include <kernel/test_support/filesystem/ext2.hpp>
+#include <kernel/test_support/filesystems/ext2.hpp>
 
-#include <kernel/filesystem/ext2/block_group_descriptor.hpp>
-#include <kernel/filesystem/ext2/filesystem.hpp>
-#include <kernel/filesystem/ext2/inode.hpp>
-#include <kernel/filesystem/ext2/superblock.hpp>
+#include <kernel/filesystems/ext2/block_group_descriptor.hpp>
+#include <kernel/filesystems/ext2/filesystem.hpp>
+#include <kernel/filesystems/ext2/inode.hpp>
+#include <kernel/filesystems/ext2/superblock.hpp>
 #include <kernel/test_support/devices/block_device.hpp>
 
 #include <kstd/units.hpp>
@@ -13,7 +13,7 @@
 
 using namespace kstd::units_literals;
 
-namespace kernel::tests::filesystem::ext2
+namespace kernel::tests::filesystems::ext2
 {
   namespace
   {
@@ -39,8 +39,8 @@ namespace kernel::tests::filesystem::ext2
 
   auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device) -> void
   {
-    auto superblock = kernel::filesystem::ext2::superblock{};
-    superblock.magic = kernel::filesystem::ext2::constants::magic_number;
+    auto superblock = kernel::filesystems::ext2::superblock{};
+    superblock.magic = kernel::filesystems::ext2::constants::magic_number;
     superblock.log_block_size = 0;
     superblock.blocks_count = 64;
     superblock.blocks_per_group = 64;
@@ -51,29 +51,30 @@ namespace kernel::tests::filesystem::ext2
   }
 
   auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
-                              kernel::filesystem::ext2::superblock const & superblock) -> void
+                              kernel::filesystems::ext2::superblock const & superblock) -> void
   {
-    auto group_descriptor = kernel::filesystem::ext2::block_group_descriptor{};
+    auto group_descriptor = kernel::filesystems::ext2::block_group_descriptor{};
     group_descriptor.inode_table = 5;
 
     setup_mock_ext2_layout(device, superblock, group_descriptor);
   }
 
   auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
-                              kernel::filesystem::ext2::superblock const & superblock,
-                              kernel::filesystem::ext2::block_group_descriptor const & group_descriptor) -> void
+                              kernel::filesystems::ext2::superblock const & superblock,
+                              kernel::filesystems::ext2::block_group_descriptor const & group_descriptor) -> void
   {
-    write_bytes(device, kernel::filesystem::ext2::constants::superblock_offset, &superblock, kstd::size_of(superblock));
+    write_bytes(device, kernel::filesystems::ext2::constants::superblock_offset, &superblock,
+                kstd::size_of(superblock));
     write_bytes(device, 2048_B, &group_descriptor, kstd::size_of(group_descriptor));
 
-    auto root_inode_data = kernel::filesystem::ext2::inode_data{};
-    root_inode_data.mode = kernel::filesystem::ext2::constants::mode_directory;
+    auto root_inode_data = kernel::filesystems::ext2::inode_data{};
+    root_inode_data.mode = kernel::filesystems::ext2::constants::mode_directory;
     root_inode_data.blocks = 2;
     root_inode_data.block[0] = root_directory_data_block;
 
     auto const root_inode_offset =
-        static_cast<size_t>(group_descriptor.inode_table) * kernel::filesystem::ext2::constants::base_block_size +
-        (kernel::filesystem::ext2::constants::root_inode_number - 1) * kstd::bytes{superblock.inode_size};
+        static_cast<size_t>(group_descriptor.inode_table) * kernel::filesystems::ext2::constants::base_block_size +
+        (kernel::filesystems::ext2::constants::root_inode_number - 1) * kstd::bytes{superblock.inode_size};
     write_bytes(device, root_inode_offset, &root_inode_data, kstd::size_of(root_inode_data));
   }
-}  // namespace kernel::tests::filesystem::ext2
\ No newline at end of file
+}  // namespace kernel::tests::filesystems::ext2
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystems/ext2.hpp b/kernel/kernel/test_support/filesystems/ext2.hpp
new file mode 100644
index 00000000..7509f1e1
--- /dev/null
+++ b/kernel/kernel/test_support/filesystems/ext2.hpp
@@ -0,0 +1,26 @@
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEMS_EXT2_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEMS_EXT2_HPP
+
+#include <kernel/filesystems/ext2/block_group_descriptor.hpp>
+#include <kernel/filesystems/ext2/superblock.hpp>
+#include <kernel/test_support/devices/block_device.hpp>
+
+#include <kstd/units.hpp>
+
+#include <cstdint>
+
+namespace kernel::tests::filesystems::ext2
+{
+  auto write_bytes(kernel::tests::devices::block_device & device, kstd::bytes offset, void const * source,
+                   kstd::bytes size) -> void;
+  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, uint32_t value) -> void;
+  auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device) -> void;
+  auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
+                              kernel::filesystems::ext2::superblock const & superblock) -> void;
+  auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
+                              kernel::filesystems::ext2::superblock const & superblock,
+                              kernel::filesystems::ext2::block_group_descriptor const & group_descriptor) -> void;
+
+}  // namespace kernel::tests::filesystems::ext2
+
+#endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/filesystem.cpp b/kernel/kernel/test_support/filesystems/filesystem.cpp
index 0d4610ab..219d85f8 100644
--- a/kernel/kernel/test_support/filesystem/filesystem.cpp
+++ b/kernel/kernel/test_support/filesystems/filesystem.cpp
@@ -1,7 +1,7 @@
-#include <kernel/test_support/filesystem/filesystem.hpp>
+#include <kernel/test_support/filesystems/filesystem.hpp>
 
-#include <kernel/filesystem/inode.hpp>
-#include <kernel/test_support/filesystem/inode.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -14,7 +14,7 @@
 #include <string_view>
 #include <utility>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::filesystems
 {
   auto filesystem::probe(inode_ptr const &) const -> kstd::result<std::uint32_t>
   {
@@ -36,4 +36,4 @@ namespace kernel::tests::filesystem
   {
     return kstd::make_shared<inode>();
   }
-}  // namespace kernel::tests::filesystem
\ No newline at end of file
+}  // namespace kernel::tests::filesystems
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/filesystem.hpp b/kernel/kernel/test_support/filesystems/filesystem.hpp
index 3df2cccb..cfbfc550 100644
--- a/kernel/kernel/test_support/filesystem/filesystem.hpp
+++ b/kernel/kernel/test_support/filesystems/filesystem.hpp
@@ -1,8 +1,8 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_FILESYSTEM_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_FILESYSTEM_HPP
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEMS_FILESYSTEM_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEMS_FILESYSTEM_HPP
 
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -14,26 +14,25 @@
 #include <optional>
 #include <string_view>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::filesystems
 {
-  struct filesystem : kernel::filesystem::filesystem
+  struct filesystem : kernel::vfs::filesystem
   {
     filesystem() = default;
 
     [[nodiscard]] auto probe(inode_ptr const & inode) const -> kstd::result<std::uint32_t> override;
 
-    auto mount(kstd::shared_ptr<kernel::filesystem::inode> const & backing_inode)
-        -> kstd::result<mount_result> override;
+    auto mount(kstd::shared_ptr<kernel::vfs::inode> const & backing_inode) -> kstd::result<mount_result> override;
 
     [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name,
                               driver_data_ptr driver_data = nullptr) const
-        -> kstd::result<kstd::shared_ptr<kernel::filesystem::inode>> override;
+        -> kstd::result<kstd::shared_ptr<kernel::vfs::inode>> override;
 
     [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
                                     driver_data_ptr driver_data = nullptr,
                                     std::optional<kapi::filesystem::device_number> = std::nullopt)
         -> kstd::result<inode_ptr> override;
   };
-}  // namespace kernel::tests::filesystem
+}  // namespace kernel::tests::filesystems
 
 #endif
diff --git a/kernel/kernel/test_support/filesystem/inode.cpp b/kernel/kernel/test_support/filesystems/inode.cpp
index 409efe77..3bba081d 100644
--- a/kernel/kernel/test_support/filesystem/inode.cpp
+++ b/kernel/kernel/test_support/filesystems/inode.cpp
@@ -1,6 +1,6 @@
-#include <kernel/test_support/filesystem/inode.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
 
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kstd/result.hpp>
 #include <kstd/units.hpp>
@@ -8,7 +8,7 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::filesystems
 {
   auto inode::read(std::span<std::byte> buffer, kstd::bytes) const -> kstd::result<kstd::bytes>
   {
@@ -24,4 +24,4 @@ namespace kernel::tests::filesystem
   {
     return true;
   }
-}  // namespace kernel::tests::filesystem
\ No newline at end of file
+}  // namespace kernel::tests::filesystems
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/inode.hpp b/kernel/kernel/test_support/filesystems/inode.hpp
index 51773f15..cdb489de 100644
--- a/kernel/kernel/test_support/filesystem/inode.hpp
+++ b/kernel/kernel/test_support/filesystems/inode.hpp
@@ -1,7 +1,7 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_INODE_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_INODE_HPP
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEMS_INODE_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEMS_INODE_HPP
 
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kstd/result.hpp>
 #include <kstd/units.hpp>
@@ -9,15 +9,15 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::filesystems
 {
-  struct inode : kernel::filesystem::inode
+  struct inode : kernel::vfs::inode
   {
     auto read(std::span<std::byte> buffer, kstd::bytes offset) const -> kstd::result<kstd::bytes> override;
     auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
 
     [[nodiscard]] auto is_regular() const -> bool override;
   };
-}  // namespace kernel::tests::filesystem
+}  // namespace kernel::tests::filesystems
 
 #endif
diff --git a/kernel/kernel/test_support/state_reset_listener.cpp b/kernel/kernel/test_support/state_reset_listener.cpp
index 59f103b7..e7d17219 100644
--- a/kernel/kernel/test_support/state_reset_listener.cpp
+++ b/kernel/kernel/test_support/state_reset_listener.cpp
@@ -1,16 +1,16 @@
 #include <kernel/devices/storage.hpp>
 #include <kernel/drivers/init.hpp>
-#include <kernel/filesystem/device_number_registry.hpp>
-#include <kernel/filesystem/driver_registry.hpp>
-#include <kernel/filesystem/open_file_table.hpp>
-#include <kernel/filesystem/vfs.hpp>
 #include <kernel/test_support/cio.hpp>
 #include <kernel/test_support/cpu.hpp>
-#include <kernel/test_support/filesystem/device_number_registry.hpp>
-#include <kernel/test_support/filesystem/driver_registry.hpp>
-#include <kernel/test_support/filesystem/open_file_table.hpp>
-#include <kernel/test_support/filesystem/vfs.hpp>
 #include <kernel/test_support/memory.hpp>
+#include <kernel/test_support/vfs/device_number_registry.hpp>
+#include <kernel/test_support/vfs/driver_registry.hpp>
+#include <kernel/test_support/vfs/open_file_table.hpp>
+#include <kernel/test_support/vfs/vfs.hpp>
+#include <kernel/vfs.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
+#include <kernel/vfs/driver_registry.hpp>
+#include <kernel/vfs/open_file_table.hpp>
 
 #include <kapi/cio.hpp>
 #include <kapi/cpu.hpp>
@@ -42,17 +42,17 @@ struct state_reset_listener : Catch::EventListenerBase
     kernel::drivers::init();
 
     std::ignore = kernel::devices::storage::init();
-    kernel::filesystem::open_file_table::init();
-    std::ignore = kernel::filesystem::device_number_registry::get();
-    kernel::filesystem::driver_registry::init();
+    kernel::vfs::open_file_table::init();
+    std::ignore = kernel::vfs::device_number_registry::get();
+    kernel::vfs::driver_registry::init();
   }
 
   void testCaseEnded(Catch::TestCaseStats const &) override
   {
-    kernel::tests::filesystem::driver_registry::deinit();
-    kernel::tests::filesystem::device_number_registry::deinit();
-    kernel::tests::filesystem::vfs::deinit();
-    kernel::tests::filesystem::open_file_table::deinit();
+    kernel::tests::vfs::driver_registry::deinit();
+    kernel::tests::vfs::device_number_registry::deinit();
+    kernel::tests::vfs::deinit();
+    kernel::tests::vfs::open_file_table::deinit();
 
     kapi::test_support::devices::deinit();
     kernel::tests::memory::deinit();
diff --git a/kernel/kernel/test_support/vfs/device_number_registry.hpp b/kernel/kernel/test_support/vfs/device_number_registry.hpp
new file mode 100644
index 00000000..8a85e7bd
--- /dev/null
+++ b/kernel/kernel/test_support/vfs/device_number_registry.hpp
@@ -0,0 +1,9 @@
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_VFS_DEVICE_NUMBER_REGISTRY_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_VFS_DEVICE_NUMBER_REGISTRY_HPP
+
+namespace kernel::tests::vfs::device_number_registry
+{
+  auto deinit() -> void;
+}
+
+#endif
diff --git a/kernel/kernel/test_support/vfs/driver_registry.hpp b/kernel/kernel/test_support/vfs/driver_registry.hpp
new file mode 100644
index 00000000..117d2824
--- /dev/null
+++ b/kernel/kernel/test_support/vfs/driver_registry.hpp
@@ -0,0 +1,10 @@
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_VFS_DRIVER_REGISTRY_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_VFS_DRIVER_REGISTRY_HPP
+
+namespace kernel::tests::vfs::driver_registry
+{
+  //! Deinitialize the FS type registry singleton.
+  auto deinit() -> void;
+}  // namespace kernel::tests::vfs::driver_registry
+
+#endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/vfs/open_file_table.hpp b/kernel/kernel/test_support/vfs/open_file_table.hpp
new file mode 100644
index 00000000..b36e4d6f
--- /dev/null
+++ b/kernel/kernel/test_support/vfs/open_file_table.hpp
@@ -0,0 +1,10 @@
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_VFS_OPEN_FILE_TABLE_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_VFS_OPEN_FILE_TABLE_HPP
+
+namespace kernel::tests::vfs::open_file_table
+{
+  //! Deinitialize the open file table singleton.
+  auto deinit() -> void;
+}  // namespace kernel::tests::vfs::open_file_table
+
+#endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.cpp b/kernel/kernel/test_support/vfs/storage_boot_module_fixture.cpp
index b9228c69..69dec962 100644
--- a/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.cpp
+++ b/kernel/kernel/test_support/vfs/storage_boot_module_fixture.cpp
@@ -1,4 +1,4 @@
-#include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
 
 #include <kernel/bus/boot_modules.hpp>
 #include <kernel/devices/storage.hpp>
@@ -25,7 +25,7 @@
 #include <sys/mman.h>
 #include <sys/stat.h>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::vfs
 {
   storage_boot_module_fixture::mapped_image::mapped_image(std::filesystem::path path)
       : file_descriptor(::open(path.c_str(), O_RDWR))
@@ -148,4 +148,4 @@ namespace kernel::tests::filesystem
 
     m_boot_module_bus->add_child(kstd::make_shared<kapi::boot_modules::device>(index, module));
   }
-}  // namespace kernel::tests::filesystem
\ No newline at end of file
+}  // namespace kernel::tests::vfs
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.hpp b/kernel/kernel/test_support/vfs/storage_boot_module_fixture.hpp
index 05830a91..34fa5356 100644
--- a/kernel/kernel/test_support/filesystem/storage_boot_module_fixture.hpp
+++ b/kernel/kernel/test_support/vfs/storage_boot_module_fixture.hpp
@@ -1,5 +1,5 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_STORAGE_BOOT_MODULE_FIXTURE_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_STORAGE_BOOT_MODULE_FIXTURE_HPP
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_VFS_STORAGE_BOOT_MODULE_FIXTURE_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_VFS_STORAGE_BOOT_MODULE_FIXTURE_HPP
 
 #include <kapi/boot_modules.hpp>
 #include <kapi/devices.hpp>
@@ -11,7 +11,7 @@
 #include <string>
 #include <vector>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::vfs
 {
   struct storage_boot_module_fixture
   {
@@ -47,6 +47,6 @@ namespace kernel::tests::filesystem
     auto setup_module_from_img(std::size_t index, std::string const & module_name,
                                std::filesystem::path const & img_path) -> void;
   };
-}  // namespace kernel::tests::filesystem
+}  // namespace kernel::tests::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/storage_boot_module_vfs_fixture.cpp b/kernel/kernel/test_support/vfs/storage_boot_module_vfs_fixture.cpp
index 02ccfec3..d21e35e5 100644
--- a/kernel/kernel/test_support/filesystem/storage_boot_module_vfs_fixture.cpp
+++ b/kernel/kernel/test_support/vfs/storage_boot_module_vfs_fixture.cpp
@@ -1,31 +1,31 @@
-#include <kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp>
 
-#include <kernel/filesystem/vfs.hpp>
-#include <kernel/test_support/filesystem/vfs.hpp>
+#include <kernel/test_support/vfs/vfs.hpp>
+#include <kernel/vfs.hpp>
 
 #include <cstddef>
 #include <filesystem>
 #include <string>
 #include <vector>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::vfs
 {
   storage_boot_module_vfs_fixture::~storage_boot_module_vfs_fixture()
   {
-    kernel::tests::filesystem::vfs::deinit();
+    kernel::tests::vfs::deinit();
   }
 
   auto storage_boot_module_vfs_fixture::setup_modules_and_init_vfs(std::size_t module_count, std::size_t module_size)
       -> void
   {
     setup_modules(module_count, module_size);
-    kernel::filesystem::vfs::init();
+    kernel::vfs::vfs::init();
   }
 
   auto storage_boot_module_vfs_fixture::setup_modules_from_img_and_init_vfs(
       std::vector<std::string> const & module_names, std::vector<std::filesystem::path> const & img_paths) -> void
   {
     setup_modules_from_img(module_names, img_paths);
-    kernel::filesystem::vfs::init();
+    kernel::vfs::vfs::init();
   }
-}  // namespace kernel::tests::filesystem
\ No newline at end of file
+}  // namespace kernel::tests::vfs
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp b/kernel/kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp
index 55f4b290..ad346e85 100644
--- a/kernel/kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp
+++ b/kernel/kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp
@@ -1,14 +1,14 @@
-#ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_STORAGE_BOOT_MODULE_VFS_FIXTURE_HPP
-#define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_STORAGE_BOOT_MODULE_VFS_FIXTURE_HPP
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_VFS_STORAGE_BOOT_MODULE_VFS_FIXTURE_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_VFS_STORAGE_BOOT_MODULE_VFS_FIXTURE_HPP
 
-#include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
 
 #include <cstddef>
 #include <filesystem>
 #include <string>
 #include <vector>
 
-namespace kernel::tests::filesystem
+namespace kernel::tests::vfs
 {
   struct storage_boot_module_vfs_fixture : storage_boot_module_fixture
   {
@@ -18,6 +18,6 @@ namespace kernel::tests::filesystem
     auto setup_modules_from_img_and_init_vfs(std::vector<std::string> const & module_names,
                                              std::vector<std::filesystem::path> const & img_paths) -> void;
   };
-}  // namespace kernel::tests::filesystem
+}  // namespace kernel::tests::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/test_assets/README.md b/kernel/kernel/test_support/vfs/test_assets/README.md
index 718a2275..718a2275 120000
--- a/kernel/kernel/test_support/filesystem/test_assets/README.md
+++ b/kernel/kernel/test_support/vfs/test_assets/README.md
diff --git a/kernel/kernel/test_support/filesystem/test_assets/ext2_1KB_devnode_fs.img b/kernel/kernel/test_support/vfs/test_assets/ext2_1KB_devnode_fs.img
index 09e59a4f..09e59a4f 100644
--- a/kernel/kernel/test_support/filesystem/test_assets/ext2_1KB_devnode_fs.img
+++ b/kernel/kernel/test_support/vfs/test_assets/ext2_1KB_devnode_fs.img
diff --git a/kernel/kernel/test_support/filesystem/test_assets/ext2_1KB_fs.img b/kernel/kernel/test_support/vfs/test_assets/ext2_1KB_fs.img
index a5202ca3..a5202ca3 100644
--- a/kernel/kernel/test_support/filesystem/test_assets/ext2_1KB_fs.img
+++ b/kernel/kernel/test_support/vfs/test_assets/ext2_1KB_fs.img
diff --git a/kernel/kernel/test_support/filesystem/test_assets/ext2_2KB_fs.img b/kernel/kernel/test_support/vfs/test_assets/ext2_2KB_fs.img
index 7f297f07..7f297f07 100644
--- a/kernel/kernel/test_support/filesystem/test_assets/ext2_2KB_fs.img
+++ b/kernel/kernel/test_support/vfs/test_assets/ext2_2KB_fs.img
diff --git a/kernel/kernel/test_support/filesystem/test_assets/ext2_4KB_fs.img b/kernel/kernel/test_support/vfs/test_assets/ext2_4KB_fs.img
index c3f6dafb..c3f6dafb 100644
--- a/kernel/kernel/test_support/filesystem/test_assets/ext2_4KB_fs.img
+++ b/kernel/kernel/test_support/vfs/test_assets/ext2_4KB_fs.img
diff --git a/kernel/kernel/test_support/filesystem/vfs.hpp b/kernel/kernel/test_support/vfs/vfs.hpp
index 739e3530..9d1e16d8 100644
--- a/kernel/kernel/test_support/filesystem/vfs.hpp
+++ b/kernel/kernel/test_support/vfs/vfs.hpp
@@ -1,10 +1,10 @@
 #ifndef TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_VFS_HPP
 #define TEACHOS_KERNEL_TEST_SUPPORT_FILESYSTEM_VFS_HPP
 
-namespace kernel::tests::filesystem::vfs
+namespace kernel::tests::vfs
 {
   //! Deinitialize the VFS singleton.
   auto deinit() -> void;
-}  // namespace kernel::tests::filesystem::vfs
+}  // namespace kernel::tests::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/vfs.cpp b/kernel/kernel/vfs.cpp
index 4645fd54..9dee6386 100644
--- a/kernel/kernel/filesystem/vfs.cpp
+++ b/kernel/kernel/vfs.cpp
@@ -1,16 +1,16 @@
-#include <kernel/filesystem/vfs.hpp>
-
-#include <kernel/filesystem/constants.hpp>
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/device_number_registry.hpp>
-#include <kernel/filesystem/driver_registry.hpp>
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
-#include <kernel/filesystem/mount.hpp>
-#include <kernel/filesystem/mount_table.hpp>
-#include <kernel/filesystem/path.hpp>
+#include <kernel/vfs.hpp>
+
+#include <kernel/vfs/constants.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/device_inode.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
+#include <kernel/vfs/driver_registry.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
+#include <kernel/vfs/mount.hpp>
+#include <kernel/vfs/mount_table.hpp>
+#include <kernel/vfs/path.hpp>
 
 #include <kapi/filesystem.hpp>
 #include <kapi/system.hpp>
@@ -35,10 +35,10 @@ using namespace kstd::units_literals;
 
 namespace
 {
-  constinit auto static active_vfs = std::optional<kernel::filesystem::vfs>{};
+  constinit auto static active_vfs = std::optional<kernel::vfs::vfs>{};
 }  // namespace
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   auto vfs::init() -> void
   {
@@ -143,7 +143,7 @@ namespace kernel::filesystem
       auto number = inode->raw_device();
       if (!number)
       {
-        return kstd::failure(vfs_errc::no_such_device);
+        return kstd::failure(errc::no_such_device);
       }
 
       auto type = inode->is_block_device() ? kapi::filesystem::file_type::block_device
@@ -172,14 +172,14 @@ namespace kernel::filesystem
       mount.value()->decrement_ref_count();
       return kstd::success();
     }
-    return kstd::failure(vfs_errc::invalid_path);
+    return kstd::failure(errc::invalid_path);
   }
 
   auto vfs::mount(std::string_view source, std::string_view target) -> kstd::result<void>
   {
     if (!path::is_valid_path(source) || !path::is_valid_path(target))
     {
-      return kstd::failure(vfs_errc::invalid_path);
+      return kstd::failure(errc::invalid_path);
     }
 
     auto resolved_target = resolve_path_internal(target);
@@ -217,7 +217,7 @@ namespace kernel::filesystem
   {
     if (!path::is_valid_path(path))
     {
-      return kstd::failure(vfs_errc::invalid_path);
+      return kstd::failure(errc::invalid_path);
     }
 
     auto remove_result = m_mount_table.remove_mount(path);
@@ -227,18 +227,18 @@ namespace kernel::filesystem
     }
     else if (remove_result == mount_table::operation_result::mount_not_found)
     {
-      return kstd::failure(vfs_errc::mount_point_not_found);
+      return kstd::failure(errc::mount_point_not_found);
     }
     else if (remove_result == mount_table::operation_result::cannot_be_unmounted)
     {
-      return kstd::failure(vfs_errc::mount_busy);
+      return kstd::failure(errc::mount_busy);
     }
     else if (remove_result == mount_table::operation_result::has_child_mounts)
     {
-      return kstd::failure(vfs_errc::has_child_mounts);
+      return kstd::failure(errc::has_child_mounts);
     }
 
-    return kstd::failure(vfs_errc::unmount_failed);
+    return kstd::failure(errc::unmount_failed);
   }
 
   auto vfs::mkdir(std::string_view path) -> kstd::result<void>
@@ -274,7 +274,7 @@ namespace kernel::filesystem
       return create_inode(path, kapi::filesystem::file_type::character_device, device);
     }
 
-    return kstd::failure(vfs_errc::invalid_argument);
+    return kstd::failure(errc::invalid_argument);
   }
 
   auto vfs::create_inode(std::string_view path, kapi::filesystem::file_type type,
@@ -282,18 +282,18 @@ namespace kernel::filesystem
   {
     if (!path::is_valid_path(path))
     {
-      return kstd::failure(vfs_errc::invalid_path);
+      return kstd::failure(errc::invalid_path);
     }
 
     if (resolve_path(path))
     {
-      return kstd::failure(vfs_errc::file_exists);
+      return kstd::failure(errc::file_exists);
     }
 
     auto [parent_path, name] = path::split_into_path_and_filename(path);
     if (name.empty())
     {
-      return kstd::failure(vfs_errc::invalid_path);
+      return kstd::failure(errc::invalid_path);
     }
 
     auto resolved_parent = resolve_path_internal(parent_path);
@@ -318,7 +318,7 @@ namespace kernel::filesystem
       }
     }
 
-    return kstd::failure(vfs_errc::no_such_file_or_directory);
+    return kstd::failure(errc::no_such_file_or_directory);
   }
 
   auto vfs::graft_persistent_device_fs(kstd::shared_ptr<filesystem> const & device_fs,
@@ -344,7 +344,7 @@ namespace kernel::filesystem
   {
     if (!path::is_valid_absolute_path(path))
     {
-      return kstd::failure(vfs_errc::invalid_path);
+      return kstd::failure(errc::invalid_path);
     }
 
     auto current_mount = m_mount_table.find_mount("/");
@@ -368,7 +368,7 @@ namespace kernel::filesystem
 
       if (!current_dentry->inode()->is_directory())
       {
-        return kstd::failure(vfs_errc::not_a_directory);
+        return kstd::failure(errc::not_a_directory);
       }
 
       if (part == ".")
@@ -428,7 +428,7 @@ namespace kernel::filesystem
       {
         if (symlink_counter++ > constants::symloop_max)
         {
-          return kstd::failure(vfs_errc::too_many_symbolic_link_levels);
+          return kstd::failure(errc::too_many_symbolic_link_levels);
         }
 
         kstd::vector<std::byte> buffer(constants::symlink_max_path_length);
@@ -470,12 +470,12 @@ namespace kernel::filesystem
     return resolve_path_internal(path).transform([](auto result) { return result.second; });
   }
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
-namespace kernel::tests::filesystem::vfs
+namespace kernel::tests::vfs
 {
   auto deinit() -> void
   {
     active_vfs.reset();
   }
-}  // namespace kernel::tests::filesystem::vfs
+}  // namespace kernel::tests::vfs
diff --git a/kernel/kernel/filesystem/vfs.hpp b/kernel/kernel/vfs.hpp
index a53ab532..fed967d0 100644
--- a/kernel/kernel/filesystem/vfs.hpp
+++ b/kernel/kernel/vfs.hpp
@@ -1,11 +1,25 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_VFS_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_VFS_HPP
-
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
-#include <kernel/filesystem/mount.hpp>
-#include <kernel/filesystem/mount_table.hpp>
+#ifndef TEACHOS_KERNEL_VFS_HPP
+#define TEACHOS_KERNEL_VFS_HPP
+
+#include <kernel/vfs/byte_offset_file_descriptor.hpp>  // IWYU pragma: export
+#include <kernel/vfs/constants.hpp>                    // IWYU pragma: export
+#include <kernel/vfs/dentry.hpp>                       // IWYU pragma: export
+#include <kernel/vfs/device_inode.hpp>                 // IWYU pragma: export
+#include <kernel/vfs/device_number_registry.hpp>       // IWYU pragma: export
+#include <kernel/vfs/directory_file_descriptor.hpp>    // IWYU pragma: export
+#include <kernel/vfs/directory_listing_cursor.hpp>     // IWYU pragma: export
+#include <kernel/vfs/directory_listing_entry.hpp>      // IWYU pragma: export
+#include <kernel/vfs/driver_registry.hpp>              // IWYU pragma: export
+#include <kernel/vfs/error.hpp>                        // IWYU pragma: export
+#include <kernel/vfs/file_type_bindings.hpp>           // IWYU pragma: export
+#include <kernel/vfs/filesystem.hpp>                   // IWYU pragma: export
+#include <kernel/vfs/inode.hpp>                        // IWYU pragma: export
+#include <kernel/vfs/mount.hpp>                        // IWYU pragma: export
+#include <kernel/vfs/mount_table.hpp>                  // IWYU pragma: export
+#include <kernel/vfs/open_file_descriptor.hpp>         // IWYU pragma: export
+#include <kernel/vfs/open_file_table.hpp>              // IWYU pragma: export
+#include <kernel/vfs/path.hpp>                         // IWYU pragma: export
+#include <kernel/vfs/reserved_numbers.hpp>             // IWYU pragma: export
 
 #include <kapi/filesystem.hpp>
 
@@ -18,7 +32,7 @@
 #include <string_view>
 #include <utility>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   //! The virtual filesystem interface.
   //!
@@ -120,6 +134,6 @@ namespace kernel::filesystem
 
     mount_table m_mount_table{};
   };
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/vfs.tests.cpp b/kernel/kernel/vfs.tests.cpp
index aac384fb..475daf2d 100644
--- a/kernel/kernel/filesystem/vfs.tests.cpp
+++ b/kernel/kernel/vfs.tests.cpp
@@ -1,10 +1,10 @@
-#include <kernel/filesystem/vfs.hpp>
+#include <kernel/vfs.hpp>
 
-#include <kernel/filesystem/byte_offset_file_descriptor.hpp>
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/open_file_descriptor.hpp>
-#include <kernel/filesystem/reserved_numbers.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/vfs/byte_offset_file_descriptor.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
+#include <kernel/vfs/reserved_numbers.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -23,8 +23,7 @@
 
 using namespace kstd::units_literals;
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS with dummy modules",
-                "[filesystem][vfs]")
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture, "VFS with dummy modules", "[filesystem][vfs]")
 {
   GIVEN("an initialized boot module registry with multiple modules")
   {
@@ -32,7 +31,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("vfs initializes and provides /dev mount")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto dev = vfs.open("/dev");
 
       REQUIRE(dev != nullptr);
@@ -40,7 +39,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("vfs initializes root filesystem with boot device if boot module is present")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto root_file = vfs.open("/");
 
       REQUIRE(root_file != nullptr);
@@ -48,7 +47,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS with file backed image",
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture, "VFS with file backed image",
                 "[filesystem][vfs][img]")
 {
   auto const image_path_1 = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
@@ -62,7 +61,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("vfs initializes and provides expected mount points")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto root = vfs.open("/");
       auto dev = vfs.open("/dev");
       auto information = vfs.open("/information/info_1.txt");
@@ -80,7 +79,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("vfs hides the image's /dev behind the devfs mount")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
 
       auto image_1 = vfs.open("/dev/image_1.txt");
       REQUIRE(image_1.error() == kstd::errc::no_such_file_or_directory);
@@ -98,11 +97,11 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     REQUIRE_NOTHROW(setup_modules_from_img_and_init_vfs({"test_img_module_1", "test_img_module_2", "test_img_module_3"},
                                                         {image_path_1, image_path_2, image_path_3}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
 
     THEN("vfs initializes first module as root")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto info1 = vfs.open("/information/info_1.txt");
       auto info2 = vfs.open("/information/info_2.txt");
 
@@ -346,7 +345,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("a new file can be created and read again")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(vfs.create("/information/new_file.txt"));
 
       auto new_file = vfs.open("/information/new_file.txt");
@@ -355,32 +354,32 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("a new directory can be created and read again")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(vfs.mkdir("/information/new_directory"));
     }
 
     THEN("a new file cannot be created if it already exists")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(!vfs.create("/information/info_1.txt"));
     }
 
     THEN("a new directory cannot be created if it already exists")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(!vfs.mkdir("/information"));
     }
 
     THEN("a new file cannot be created if path does not exist or is invalid")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(!vfs.create(""));
       REQUIRE(!vfs.create("invalid_path"));
     }
 
     THEN("a new directory cannot be created if path does not exist or is invalid")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(!vfs.mkdir(""));
       REQUIRE(!vfs.mkdir("invalid_path"));
     }
@@ -393,7 +392,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("the file-filesystem in the image can be mounted, files can be read and unmounted again")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(vfs.mount("/archiv/2024.img", "/information"));
 
       auto info_1 = vfs.open("/information/info_1.txt");
@@ -401,7 +400,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
       auto dentry = vfs.open("/information/sheep_1.txt");
       REQUIRE(dentry != nullptr);
-      auto sheep_1_ofd = kstd::make_shared<kernel::filesystem::byte_offset_file_descriptor>(dentry.value());
+      auto sheep_1_ofd = kstd::make_shared<kernel::vfs::byte_offset_file_descriptor>(dentry.value());
 
       kstd::vector<std::byte> buffer(7);
       auto bytes_read = sheep_1_ofd->read(buffer);
@@ -418,7 +417,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     THEN("the file-filesystem in the image can be mounted and in this filesystem can another file-filesystem be "
          "mounted, files can be read and unmounted again")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       REQUIRE(vfs.mount("/archiv/2024.img", "/information"));
       REQUIRE(vfs.mount("/archiv/2025.img", "/information/stable"));
 
@@ -427,8 +426,8 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(sheep_1 != nullptr);
       REQUIRE(goat_1 != nullptr);
 
-      auto sheep_1_ofd = kstd::make_shared<kernel::filesystem::byte_offset_file_descriptor>(sheep_1.value());
-      auto goat_1_ofd = kstd::make_shared<kernel::filesystem::byte_offset_file_descriptor>(goat_1.value());
+      auto sheep_1_ofd = kstd::make_shared<kernel::vfs::byte_offset_file_descriptor>(sheep_1.value());
+      auto goat_1_ofd = kstd::make_shared<kernel::vfs::byte_offset_file_descriptor>(goat_1.value());
 
       kstd::vector<std::byte> sheep_buffer(7);
       auto bytes_read = sheep_1_ofd->read(sheep_buffer);
@@ -467,7 +466,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     REQUIRE_NOTHROW(
         setup_modules_from_img_and_init_vfs({"test_img_module_3", "test_img_module_1"}, {image_path_3, image_path_1}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
 
     THEN("cannot unmount a filesystem if files are mounted")
     {
@@ -496,56 +495,56 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
     THEN("file can be opened through absolute symbolic link")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto info_1 = vfs.open("/symlinks/info_1_absolute");
       REQUIRE(info_1 != nullptr);
     }
 
     THEN("file can be opened through relative symbolic link")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto info_1 = vfs.open("/symlinks/info_1_relative");
       REQUIRE(info_1 != nullptr);
     }
 
     THEN("file can be opened through symbolic link pointing absolute to the directory containing the file")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto info_1 = vfs.open("/symlinks/information_directory_absolute/info_1.txt");
       REQUIRE(info_1 != nullptr);
     }
 
     THEN("file can be opened through symbolic link pointing relative to the directory containing the file")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto info_1 = vfs.open("/symlinks/information_directory_relative/info_1.txt");
       REQUIRE(info_1 != nullptr);
     }
 
     THEN("symbolic link with path traversing back to the root")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto info_1 = vfs.open("/symlinks/traverse_back_5_times/information/info_1.txt");
       REQUIRE(info_1 != nullptr);
     }
 
     THEN("symbolic link containing an invalid absolute path is handled correctly")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto invalid_symlink = vfs.open("/symlinks/invalid_absolute");
       REQUIRE(invalid_symlink.error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("symbolic link containing an invalid relative path is handled correctly")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto invalid_symlink = vfs.open("/symlinks/invalid_relative");
       REQUIRE(invalid_symlink.error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("circular symbolic links are detected and handled correctly")
     {
-      auto & vfs = kernel::filesystem::vfs::get();
+      auto & vfs = kernel::vfs::vfs::get();
       auto circular_symlink = vfs.open("/symlinks/symloop_a");
       REQUIRE(circular_symlink.error() == kstd::errc::too_many_symbolic_link_levels);
     }
@@ -556,7 +555,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     REQUIRE(std::filesystem::exists(image_path_1));
     REQUIRE_NOTHROW(setup_modules_from_img_and_init_vfs({"test_img_module_1"}, {image_path_1}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
     REQUIRE(vfs.mount("/archiv/2024.img", "/information"));
 
     THEN("file can be opened through symbolic link pointing to the parent filesystem")
@@ -573,7 +572,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     REQUIRE_NOTHROW(
         setup_modules_from_img_and_init_vfs({"test_img_module_1", "test_img_module_2"}, {image_path_1, image_path_2}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
     REQUIRE(vfs.mount("/dev/ram1", "/information"));
 
     THEN("file can be opened through symbolic link pointing to the parent filesystem and back into the mounted "
@@ -589,7 +588,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     REQUIRE(std::filesystem::exists(image_path_3));
     REQUIRE_NOTHROW(setup_modules_from_img_and_init_vfs({"test_img_module_3"}, {image_path_3}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
 
     THEN("file can be opened through symbolic link with a long path")
     {
@@ -603,7 +602,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     REQUIRE(std::filesystem::exists(image_path_3));
     REQUIRE_NOTHROW(setup_modules_from_img_and_init_vfs({"test_img_module_3"}, {image_path_3}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
 
     THEN("file can be opened through symbolic link chain")
     {
@@ -613,7 +612,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS status()", "[filesystem][vfs][img]")
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture, "VFS status()", "[filesystem][vfs][img]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
 
@@ -622,14 +621,14 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     REQUIRE(std::filesystem::exists(image_path));
     REQUIRE_NOTHROW(setup_modules_from_img_and_init_vfs({"test_img_module"}, {image_path}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
 
     THEN("status(/dev/ram0) reports it as the correct block device")
     {
       auto result = vfs.status("/dev/ram0");
       REQUIRE(result);
       REQUIRE(kapi::filesystem::is_block_device(result->mode));
-      REQUIRE(result->raw_device.major == kernel::filesystem::block_major_numbers::ram_disk);
+      REQUIRE(result->raw_device.major == kernel::vfs::block_major_numbers::ram_disk);
     }
 
     THEN("status(/information/info_1.txt) reports it as a regular file")
diff --git a/kernel/kernel/filesystem/byte_offset_file_descriptor.cpp b/kernel/kernel/vfs/byte_offset_file_descriptor.cpp
index 6071155c..7e99a3fb 100644
--- a/kernel/kernel/filesystem/byte_offset_file_descriptor.cpp
+++ b/kernel/kernel/vfs/byte_offset_file_descriptor.cpp
@@ -1,6 +1,6 @@
-#include <kernel/filesystem/byte_offset_file_descriptor.hpp>
+#include <kernel/vfs/byte_offset_file_descriptor.hpp>
 
-#include <kernel/filesystem/dentry.hpp>
+#include <kernel/vfs/dentry.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -11,7 +11,7 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   auto byte_offset_file_descriptor::read(std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
@@ -80,4 +80,4 @@ namespace kernel::filesystem
     return m_offset;
   }
 
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/byte_offset_file_descriptor.hpp b/kernel/kernel/vfs/byte_offset_file_descriptor.hpp
index 50eedb67..4008d500 100644
--- a/kernel/kernel/filesystem/byte_offset_file_descriptor.hpp
+++ b/kernel/kernel/vfs/byte_offset_file_descriptor.hpp
@@ -1,9 +1,9 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_BYTE_OFFSET_FILE_DESCRIPTOR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_BYTE_OFFSET_FILE_DESCRIPTOR_HPP
+#ifndef TEACHOS_KERNEL_VFS_BYTE_OFFSET_FILE_DESCRIPTOR_HPP
+#define TEACHOS_KERNEL_VFS_BYTE_OFFSET_FILE_DESCRIPTOR_HPP
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/open_file_descriptor.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -14,7 +14,7 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   //! An open file.
   //!
@@ -36,6 +36,6 @@ namespace kernel::filesystem
     kstd::bytes m_offset{};
   };
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/byte_offset_file_descriptor.tests.cpp b/kernel/kernel/vfs/byte_offset_file_descriptor.tests.cpp
index a17ce686..ed934a16 100644
--- a/kernel/kernel/filesystem/byte_offset_file_descriptor.tests.cpp
+++ b/kernel/kernel/vfs/byte_offset_file_descriptor.tests.cpp
@@ -1,13 +1,10 @@
-#include <kernel/filesystem/byte_offset_file_descriptor.hpp>
+#include <kernel/vfs/byte_offset_file_descriptor.hpp>
 
 #include <kernel/devices/storage.hpp>
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/device_inode.hpp>
-#include <kernel/filesystem/inode.hpp>
-#include <kernel/filesystem/vfs.hpp>
-#include <kernel/test_support/filesystem/inode.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/vfs.hpp>
 
 #include <kapi/devices.hpp>
 
@@ -33,9 +30,9 @@ SCENARIO("Open file descriptor construction", "[filesystem][byte_offset_file_des
 {
   GIVEN("a dentry and an open file descriptor for that dentry")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "test_dentry");
-    auto file_descriptor = kernel::filesystem::byte_offset_file_descriptor{dentry};
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "test_dentry");
+    auto file_descriptor = kernel::vfs::byte_offset_file_descriptor{dentry};
 
     THEN("the initial offset is zero")
     {
@@ -48,9 +45,9 @@ SCENARIO("Open file descriptor read/write offset management", "[filesystem][byte
 {
   GIVEN("a dentry that tracks read/write calls and an open file descriptor for that dentry")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "test_dentry");
-    auto file_descriptor = kernel::filesystem::byte_offset_file_descriptor{dentry};
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "test_dentry");
+    auto file_descriptor = kernel::vfs::byte_offset_file_descriptor{dentry};
 
     THEN("the offset is updated correctly after reads")
     {
@@ -88,7 +85,7 @@ SCENARIO("Open file descriptor read/write offset management", "[filesystem][byte
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Open file descriptor read with real image",
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture, "Open file descriptor read with real image",
                 "[filesystem][byte_offset_file_descriptor][img]")
 {
   auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
@@ -98,10 +95,10 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Ope
     REQUIRE(std::filesystem::exists(image_path));
     REQUIRE_NOTHROW(setup_modules_from_img_and_init_vfs({"test_img_module"}, {image_path}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
     auto dentry = vfs.open("/information/info_1.txt");
     REQUIRE(dentry);
-    auto ofd = kstd::make_shared<kernel::filesystem::byte_offset_file_descriptor>(dentry.value());
+    auto ofd = kstd::make_shared<kernel::vfs::byte_offset_file_descriptor>(dentry.value());
 
     THEN("the file can be read and the offset is updated")
     {
@@ -152,7 +149,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Ope
   }
 }
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Open file descriptor handles device removal",
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture, "Open file descriptor handles device removal",
                 "[filesystem][byte_offset_file_descriptor]")
 {
   GIVEN("A file descriptor open on a bound, published devices")
@@ -164,9 +161,9 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Open fi
 
     auto weak_reference = kstd::weak_ptr{device};
 
-    auto device_inode = kstd::make_shared<kernel::filesystem::device_inode>(device);
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, device_inode, "ram0");
-    auto fd = kstd::make_shared<kernel::filesystem::byte_offset_file_descriptor>(dentry);
+    auto device_inode = kstd::make_shared<kernel::vfs::device_inode>(device);
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, device_inode, "ram0");
+    auto fd = kstd::make_shared<kernel::vfs::byte_offset_file_descriptor>(dentry);
 
     device.reset();
     REQUIRE_FALSE(weak_reference.expired());
diff --git a/kernel/kernel/filesystem/constants.hpp b/kernel/kernel/vfs/constants.hpp
index 09996467..b5759d32 100644
--- a/kernel/kernel/filesystem/constants.hpp
+++ b/kernel/kernel/vfs/constants.hpp
@@ -1,9 +1,9 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_CONSTANTS_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_CONSTANTS_HPP
+#ifndef TEACHOS_KERNEL_VFS_CONSTANTS_HPP
+#define TEACHOS_KERNEL_VFS_CONSTANTS_HPP
 
 #include <cstddef>
 
-namespace kernel::filesystem::constants
+namespace kernel::vfs::constants
 {
   //! The maximum allowed length for any path in the system.
   constexpr size_t inline max_path_length = 4096;
@@ -13,6 +13,6 @@ namespace kernel::filesystem::constants
 
   //! The maximum number of loops allowed in a path, via symlinks.
   constexpr size_t inline symloop_max = 40;
-}  // namespace kernel::filesystem::constants
+}  // namespace kernel::vfs::constants
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/dentry.cpp b/kernel/kernel/vfs/dentry.cpp
index e82c5419..a7bfc3cb 100644
--- a/kernel/kernel/filesystem/dentry.cpp
+++ b/kernel/kernel/vfs/dentry.cpp
@@ -1,6 +1,6 @@
-#include <kernel/filesystem/dentry.hpp>
+#include <kernel/vfs/dentry.hpp>
 
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/system.hpp>
 
@@ -11,9 +11,9 @@
 #include <cstdint>
 #include <string_view>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
-  dentry::dentry(kstd::shared_ptr<dentry> const & parent, kstd::shared_ptr<kernel::filesystem::inode> const & inode,
+  dentry::dentry(kstd::shared_ptr<dentry> const & parent, kstd::shared_ptr<kernel::vfs::inode> const & inode,
                  std::string_view name)
       : m_name(name)
       , m_parent(parent)
@@ -30,7 +30,7 @@ namespace kernel::filesystem
     }
   }
 
-  auto dentry::inode() const -> kstd::shared_ptr<kernel::filesystem::inode> const &
+  auto dentry::inode() const -> kstd::shared_ptr<kernel::vfs::inode> const &
   {
     return m_inode;
   }
@@ -93,4 +93,4 @@ namespace kernel::filesystem
   {
     return (m_flags & static_cast<uint32_t>(flag)) != 0;
   }
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/dentry.hpp b/kernel/kernel/vfs/dentry.hpp
index f7897764..b15a6f6c 100644
--- a/kernel/kernel/filesystem/dentry.hpp
+++ b/kernel/kernel/vfs/dentry.hpp
@@ -1,7 +1,7 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DENTRY_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DENTRY_HPP
+#ifndef TEACHOS_KERNEL_VFS_DENTRY_HPP
+#define TEACHOS_KERNEL_VFS_DENTRY_HPP
 
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/string.hpp>
@@ -10,13 +10,13 @@
 #include <cstdint>
 #include <string_view>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   //! A directory entry in the filesystem.
   struct dentry
   {
     using dentry_ptr = kstd::shared_ptr<dentry>;
-    using inode_ptr = kstd::shared_ptr<kernel::filesystem::inode>;
+    using inode_ptr = kstd::shared_ptr<kernel::vfs::inode>;
 
     //! Flags for the dentry.
     enum class dentry_flags : uint32_t
@@ -93,6 +93,6 @@ namespace kernel::filesystem
     inode_ptr m_inode;
     uint32_t m_flags;
   };
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/dentry.tests.cpp b/kernel/kernel/vfs/dentry.tests.cpp
index cf3915de..a504354c 100644
--- a/kernel/kernel/filesystem/dentry.tests.cpp
+++ b/kernel/kernel/vfs/dentry.tests.cpp
@@ -1,7 +1,7 @@
-#include <kernel/filesystem/dentry.hpp>
+#include <kernel/vfs/dentry.hpp>
 
 #include <kernel/test_support/cpu.hpp>
-#include <kernel/test_support/filesystem/inode.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/print.hpp>
@@ -12,12 +12,12 @@ SCENARIO("Dentry construction", "[filesystem][dentry]")
 {
   GIVEN("A parent dentry and inode")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto parent_dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "parent");
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto parent_dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "parent");
 
     WHEN("constructing a dentry")
     {
-      auto child_dentry = kernel::filesystem::dentry{parent_dentry, inode, "child"};
+      auto child_dentry = kernel::vfs::dentry{parent_dentry, inode, "child"};
 
       THEN("the dentry has the correct parent, inode, and name")
       {
@@ -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::is_mount_point));
+        REQUIRE_FALSE(child_dentry.has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
       }
     }
 
@@ -36,13 +36,13 @@ SCENARIO("Dentry construction", "[filesystem][dentry]")
     {
       THEN("the dentry has the correct parent and inode, and an empty name")
       {
-        REQUIRE_THROWS_AS((kernel::filesystem::dentry{parent_dentry, inode, ""}), kernel::tests::cpu::halt);
+        REQUIRE_THROWS_AS((kernel::vfs::dentry{parent_dentry, inode, ""}), kernel::tests::cpu::halt);
       }
     }
 
     WHEN("constructing a dentry with a null parent")
     {
-      auto child_dentry = kernel::filesystem::dentry{nullptr, inode, "child"};
+      auto child_dentry = kernel::vfs::dentry{nullptr, inode, "child"};
 
       THEN("the dentry has a null parent, the correct inode, and the correct name")
       {
@@ -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::is_mount_point));
+        REQUIRE_FALSE(child_dentry.has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
       }
     }
 
@@ -61,7 +61,7 @@ SCENARIO("Dentry construction", "[filesystem][dentry]")
     {
       THEN("the system panics")
       {
-        REQUIRE_THROWS_AS((kernel::filesystem::dentry{parent_dentry, nullptr, "child"}), kernel::tests::cpu::halt);
+        REQUIRE_THROWS_AS((kernel::vfs::dentry{parent_dentry, nullptr, "child"}), kernel::tests::cpu::halt);
       }
     }
   }
@@ -71,13 +71,13 @@ SCENARIO("Dentry child logic", "[filesystem][dentry]")
 {
   GIVEN("A parent dentry and inode")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto parent_dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "parent");
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto parent_dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "parent");
 
     WHEN("adding child dentries")
     {
-      auto child1 = kstd::make_shared<kernel::filesystem::dentry>(parent_dentry, inode, "child1");
-      auto child2 = kstd::make_shared<kernel::filesystem::dentry>(parent_dentry, inode, "child2");
+      auto child1 = kstd::make_shared<kernel::vfs::dentry>(parent_dentry, inode, "child1");
+      auto child2 = kstd::make_shared<kernel::vfs::dentry>(parent_dentry, inode, "child2");
       parent_dentry->add_child(child1);
       parent_dentry->add_child(child2);
 
@@ -99,27 +99,27 @@ SCENARIO("Dentry Flag logic", "[filesystem][dentry]")
 {
   GIVEN("A dentry")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kernel::filesystem::dentry{nullptr, inode, "test"};
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kernel::vfs::dentry{nullptr, inode, "test"};
 
     WHEN("setting a flag")
     {
-      dentry.set_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point);
+      dentry.set_flag(kernel::vfs::dentry::dentry_flags::is_mount_point);
 
       THEN("the flag is set")
       {
-        REQUIRE(dentry.has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
+        REQUIRE(dentry.has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
       }
     }
 
     WHEN("unsetting a flag")
     {
-      dentry.set_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point);
-      dentry.unset_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point);
+      dentry.set_flag(kernel::vfs::dentry::dentry_flags::is_mount_point);
+      dentry.unset_flag(kernel::vfs::dentry::dentry_flags::is_mount_point);
 
       THEN("the flag is unset")
       {
-        REQUIRE_FALSE(dentry.has_flag(kernel::filesystem::dentry::dentry_flags::is_mount_point));
+        REQUIRE_FALSE(dentry.has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
       }
     }
   }
@@ -129,15 +129,15 @@ SCENARIO("Dentry path resolution", "[filesystem][dentry]")
 {
   GIVEN("A dentry with a parent hierarchy")
   {
-    auto root_inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode, "/");
+    auto root_inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto root_dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, root_inode, "/");
 
-    auto home_inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto home_dentry = kstd::make_shared<kernel::filesystem::dentry>(root_dentry, home_inode, "home");
+    auto home_inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto home_dentry = kstd::make_shared<kernel::vfs::dentry>(root_dentry, home_inode, "home");
     root_dentry->add_child(home_dentry);
 
-    auto user_inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto user_dentry = kstd::make_shared<kernel::filesystem::dentry>(home_dentry, user_inode, "user");
+    auto user_inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto user_dentry = kstd::make_shared<kernel::vfs::dentry>(home_dentry, user_inode, "user");
     home_dentry->add_child(user_dentry);
 
     THEN("the full path is constructed correctly")
diff --git a/kernel/kernel/filesystem/device_inode.cpp b/kernel/kernel/vfs/device_inode.cpp
index f45023d3..ebb39541 100644
--- a/kernel/kernel/filesystem/device_inode.cpp
+++ b/kernel/kernel/vfs/device_inode.cpp
@@ -1,9 +1,9 @@
-#include <kernel/filesystem/device_inode.hpp>
+#include <kernel/vfs/device_inode.hpp>
 
 #include <kernel/devices/block_device_utils.hpp>
-#include <kernel/filesystem/device_number_registry.hpp>
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/devices/device.hpp>
@@ -18,7 +18,7 @@
 #include <optional>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   device_inode::device_inode(kstd::shared_ptr<kapi::devices::device> const & device)
       : device_inode{device, nullptr}
@@ -44,7 +44,7 @@ namespace kernel::filesystem
   {
     if (m_device->state() == kapi::devices::state::removed)
     {
-      return kstd::failure(vfs_errc::no_such_device);
+      return kstd::failure(errc::no_such_device);
     }
 
     if (auto block_device =
@@ -58,14 +58,14 @@ namespace kernel::filesystem
       return character_device->read(buffer);
     }
 
-    return kstd::failure(vfs_errc::no_such_device);
+    return kstd::failure(errc::no_such_device);
   }
 
   auto device_inode::write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes>
   {
     if (m_device->state() == kapi::devices::state::removed)
     {
-      return kstd::failure(vfs_errc::no_such_device);
+      return kstd::failure(errc::no_such_device);
     }
 
     if (auto block_device =
@@ -79,7 +79,7 @@ namespace kernel::filesystem
       return character_device->write(buffer);
     }
 
-    return kstd::failure(vfs_errc::no_such_device);
+    return kstd::failure(errc::no_such_device);
   }
 
   auto device_inode::device() const -> kstd::shared_ptr<kapi::devices::device> const &
@@ -117,4 +117,4 @@ namespace kernel::filesystem
     return std::nullopt;
   }
 
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/device_inode.hpp b/kernel/kernel/vfs/device_inode.hpp
index 49b17d89..dd89c7b3 100644
--- a/kernel/kernel/filesystem/device_inode.hpp
+++ b/kernel/kernel/vfs/device_inode.hpp
@@ -1,7 +1,7 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DEVICE_INODE_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DEVICE_INODE_HPP
+#ifndef TEACHOS_KERNEL_VFS_DEVICE_INODE_HPP
+#define TEACHOS_KERNEL_VFS_DEVICE_INODE_HPP
 
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/devices/device.hpp>
 #include <kapi/filesystem.hpp>
@@ -14,7 +14,7 @@
 #include <optional>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   //! Inode implementation for device inodes in the filesystem.
@@ -98,6 +98,6 @@ namespace kernel::filesystem
     //! when applicable.
     kstd::shared_ptr<inode> m_origin;
   };
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/device_inode.tests.cpp b/kernel/kernel/vfs/device_inode.tests.cpp
index c4b117fb..0f9b5881 100644
--- a/kernel/kernel/filesystem/device_inode.tests.cpp
+++ b/kernel/kernel/vfs/device_inode.tests.cpp
@@ -1,12 +1,12 @@
-#include <kernel/filesystem/device_inode.hpp>
+#include <kernel/vfs/device_inode.hpp>
 
-#include <kernel/filesystem/device_number_registry.hpp>
-#include <kernel/filesystem/inode.hpp>
 #include <kernel/test_support/cpu.hpp>
 #include <kernel/test_support/devices/block_device.hpp>
 #include <kernel/test_support/devices/character_device.hpp>
 #include <kernel/test_support/devices/driver.hpp>
-#include <kernel/test_support/filesystem/device_number_registry.hpp>
+#include <kernel/test_support/vfs/device_number_registry.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/filesystem.hpp>
@@ -33,11 +33,11 @@ namespace
   {
     ~registry_reset_guard()
     {
-      kernel::tests::filesystem::device_number_registry::deinit();
+      kernel::tests::vfs::device_number_registry::deinit();
     }
   };
 
-  struct mock_origin_inode : kernel::filesystem::inode
+  struct mock_origin_inode : kernel::vfs::inode
   {
     auto read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes> override
     {
@@ -70,7 +70,7 @@ SCENARIO("Device inode construction", "[filesystem][device_inode]")
 
     WHEN("constructing a device inode with the block device")
     {
-      auto inode = kernel::filesystem::device_inode{device};
+      auto inode = kernel::vfs::device_inode{device};
 
       THEN("the device inode has the correct device")
       {
@@ -90,7 +90,7 @@ SCENARIO("Device inode construction", "[filesystem][device_inode]")
     {
       THEN("the constructor panics")
       {
-        REQUIRE_THROWS_AS((kernel::filesystem::device_inode{nullptr}), kernel::tests::cpu::halt);
+        REQUIRE_THROWS_AS((kernel::vfs::device_inode{nullptr}), kernel::tests::cpu::halt);
       }
     }
   }
@@ -101,7 +101,7 @@ SCENARIO("Device inode read/write", "[filesystem][device_inode]")
   GIVEN("a block device and a device inode for that device")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("test_block_device", 512_B, 3 * 512_B);
-    auto inode = kernel::filesystem::device_inode{device};
+    auto inode = kernel::vfs::device_inode{device};
 
     WHEN("writing to the device inode")
     {
@@ -135,7 +135,7 @@ SCENARIO("Device inode read/write with a non-block device", "[filesystem][device
   GIVEN("a non-block device and a device inode for that device")
   {
     auto device = kstd::make_shared<kernel::tests::devices::character_device>("test_character_device");
-    auto inode = kernel::filesystem::device_inode{device};
+    auto inode = kernel::vfs::device_inode{device};
 
     WHEN("reading from the device inode")
     {
@@ -175,11 +175,11 @@ SCENARIO("Device inode raw_device()", "[filesystem][device-inode]")
 
     REQUIRE(kapi::devices::facet_registry::get().publish<kapi::filesystem::block_special_file>(device, "ram0"));
 
-    auto inode = kernel::filesystem::device_inode{device};
+    auto inode = kernel::vfs::device_inode{device};
 
     THEN("raw_device() return the number assigned to the device")
     {
-      auto expected = kernel::filesystem::device_number_registry::get().number_of(*device);
+      auto expected = kernel::vfs::device_number_registry::get().number_of(*device);
       REQUIRE(expected);
 
       auto actual = inode.raw_device();
@@ -190,7 +190,7 @@ SCENARIO("Device inode raw_device()", "[filesystem][device-inode]")
   GIVEN("a block device that has never been published")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("never_published", 512_B);
-    auto inode = kernel::filesystem::device_inode{device};
+    auto inode = kernel::vfs::device_inode{device};
 
     THEN("raw_device() is nullopt, not a stale or default number")
     {
@@ -206,7 +206,7 @@ SCENARIO("Device inode status()", "[filesystem][device_inode]")
   GIVEN("a device inode with no origin")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("ram0", 512_B);
-    auto inode = kernel::filesystem::device_inode{device};
+    auto inode = kernel::vfs::device_inode{device};
 
     THEN("status() falls back to the minimal default")
     {
@@ -222,7 +222,7 @@ SCENARIO("Device inode status()", "[filesystem][device_inode]")
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>("ram0", 512_B, 512_B);
     auto origin = kstd::make_shared<mock_origin_inode>();
-    auto inode = kernel::filesystem::device_inode{device, origin};
+    auto inode = kernel::vfs::device_inode{device, origin};
 
     THEN("status() forwards to the origin outright, not device_inode's own default")
     {
diff --git a/kernel/kernel/filesystem/device_number_registry.cpp b/kernel/kernel/vfs/device_number_registry.cpp
index 64cdb062..738ce043 100644
--- a/kernel/kernel/filesystem/device_number_registry.cpp
+++ b/kernel/kernel/vfs/device_number_registry.cpp
@@ -1,7 +1,7 @@
-#include <kernel/filesystem/device_number_registry.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
 
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/file_type_bindings.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/file_type_bindings.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/filesystem.hpp>
@@ -20,10 +20,10 @@
 
 namespace
 {
-  constinit auto static instance = std::optional<kernel::filesystem::device_number_registry>{};
+  constinit auto static instance = std::optional<kernel::vfs::device_number_registry>{};
 }  // namespace
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   auto device_number_registry::get() -> device_number_registry &
@@ -66,7 +66,7 @@ namespace kernel::filesystem
 
     if (found == std::ranges::cend(m_entries))
     {
-      return kstd::failure(vfs_errc::no_such_device);
+      return kstd::failure(errc::no_such_device);
     }
 
     if (auto device = found->device.lock())
@@ -74,7 +74,7 @@ namespace kernel::filesystem
       return device;
     }
 
-    return kstd::failure(vfs_errc::no_such_device);
+    return kstd::failure(errc::no_such_device);
   }
 
   auto device_number_registry::number_of(kapi::devices::device const & device) const
@@ -91,7 +91,7 @@ namespace kernel::filesystem
 
     if (found == std::ranges::cend(m_entries))
     {
-      return kstd::failure(vfs_errc::no_such_device);
+      return kstd::failure(errc::no_such_device);
     }
 
     return found->number;
@@ -272,12 +272,12 @@ namespace kernel::filesystem
     return candidate;
   }
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
-namespace kernel::tests::filesystem::device_number_registry
+namespace kernel::tests::vfs::device_number_registry
 {
   auto deinit() -> void
   {
     instance.reset();
   }
-}  // namespace kernel::tests::filesystem::device_number_registry
+}  // namespace kernel::tests::vfs::device_number_registry
diff --git a/kernel/kernel/filesystem/device_number_registry.hpp b/kernel/kernel/vfs/device_number_registry.hpp
index 2f0f0226..734da498 100644
--- a/kernel/kernel/filesystem/device_number_registry.hpp
+++ b/kernel/kernel/vfs/device_number_registry.hpp
@@ -1,5 +1,5 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DEVICE_NUMBER_REGISTRY_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DEVICE_NUMBER_REGISTRY_HPP
+#ifndef TEACHOS_KERNEL_VFS_DEVICE_NUMBER_REGISTRY_HPP
+#define TEACHOS_KERNEL_VFS_DEVICE_NUMBER_REGISTRY_HPP
 
 #include <kapi/devices.hpp>
 #include <kapi/filesystem.hpp>
@@ -13,7 +13,7 @@
 
 #include <cstdint>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   struct device_number_registry_observer;
@@ -112,6 +112,6 @@ namespace kernel::filesystem
     virtual auto on_device_unnumbered(device_number_registry::entry const & unnumbered) -> void = 0;
   };
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
diff --git a/kernel/kernel/filesystem/device_number_registry.tests.cpp b/kernel/kernel/vfs/device_number_registry.tests.cpp
index 60e17337..abaacd74 100644
--- a/kernel/kernel/filesystem/device_number_registry.tests.cpp
+++ b/kernel/kernel/vfs/device_number_registry.tests.cpp
@@ -1,4 +1,4 @@
-#include <kernel/filesystem/device_number_registry.hpp>
+#include <kernel/vfs/device_number_registry.hpp>
 
 #include <kernel/test_support/devices/block_device.hpp>
 #include <kernel/test_support/devices/driver.hpp>
@@ -39,7 +39,7 @@ SCENARIO("Device number registry resolves and numbers published block devices",
          "[kernel][filesystem][device_number_registry]")
 {
   auto facets = kapi::devices::facet_registry{};
-  auto registry = kernel::filesystem::device_number_registry{facets};
+  auto registry = kernel::vfs::device_number_registry{facets};
 
   GIVEN("No devices have been published")
   {
diff --git a/kernel/kernel/filesystem/directory_file_descriptor.cpp b/kernel/kernel/vfs/directory_file_descriptor.cpp
index 8c73ae86..fd60d1d5 100644
--- a/kernel/kernel/filesystem/directory_file_descriptor.cpp
+++ b/kernel/kernel/vfs/directory_file_descriptor.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/directory_file_descriptor.hpp>
+#include <kernel/vfs/directory_file_descriptor.hpp>
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/result.hpp>
@@ -10,7 +10,7 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   auto directory_file_descriptor::read_directory(std::span<directory_listing_entry> entries)
@@ -31,4 +31,4 @@ namespace kernel::filesystem
     return m_position;
   }
 
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/directory_file_descriptor.hpp b/kernel/kernel/vfs/directory_file_descriptor.hpp
index 075937ca..92649783 100644
--- a/kernel/kernel/filesystem/directory_file_descriptor.hpp
+++ b/kernel/kernel/vfs/directory_file_descriptor.hpp
@@ -1,10 +1,10 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DIRECTORY_FILE_DESCRIPTOR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DIRECTORY_FILE_DESCRIPTOR_HPP
+#ifndef TEACHOS_KERNEL_VFS_DIRECTORY_FILE_DESCRIPTOR_HPP
+#define TEACHOS_KERNEL_VFS_DIRECTORY_FILE_DESCRIPTOR_HPP
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/open_file_descriptor.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -15,7 +15,7 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   struct directory_file_descriptor : open_file_descriptor
@@ -30,6 +30,6 @@ namespace kernel::filesystem
     directory_listing_cursor m_position{};
   };
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/directory_file_descriptor.tests.cpp b/kernel/kernel/vfs/directory_file_descriptor.tests.cpp
index ac60aad9..dd7a5afc 100644
--- a/kernel/kernel/filesystem/directory_file_descriptor.tests.cpp
+++ b/kernel/kernel/vfs/directory_file_descriptor.tests.cpp
@@ -1,11 +1,11 @@
-#include <kernel/filesystem/directory_file_descriptor.hpp>
+#include <kernel/vfs/directory_file_descriptor.hpp>
 
 #include <kernel/devices/storage.hpp>
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/vfs.hpp>
-#include <kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp>
+#include <kernel/vfs.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture,
+SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture,
                 "directory_file_descriptor owns its cursor across calls, not the caller",
                 "[filesystem][directory_file_descriptor][img]")
 {
@@ -31,15 +31,15 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture,
     REQUIRE(std::filesystem::exists(image_path));
     REQUIRE_NOTHROW(setup_modules_from_img_and_init_vfs({"test_img_module"}, {image_path}));
 
-    auto & vfs = kernel::filesystem::vfs::get();
+    auto & vfs = kernel::vfs::vfs::get();
     auto dentry = vfs.open("/information");
     REQUIRE(dentry);
 
-    auto fd = kernel::filesystem::directory_file_descriptor{dentry.value()};
+    auto fd = kernel::vfs::directory_file_descriptor{dentry.value()};
 
     THEN("position starts at a default-constructed cursor")
     {
-      REQUIRE(fd.position() == kernel::filesystem::directory_listing_cursor{});
+      REQUIRE(fd.position() == kernel::vfs::directory_listing_cursor{});
     }
 
     WHEN("read_directory is called one entry at a time, with no cursor passed by the caller")
@@ -48,7 +48,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture,
 
       for (auto guard = 0; guard < 16; ++guard)
       {
-        auto one = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
+        auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
         auto result = fd.read_directory(one);
         REQUIRE(result);
         if (*result == 0)
@@ -60,7 +60,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture,
 
       THEN("every call advanced position on its own, and the known entries all appear exactly once")
       {
-        REQUIRE(fd.position() != kernel::filesystem::directory_listing_cursor{});
+        REQUIRE(fd.position() != kernel::vfs::directory_listing_cursor{});
         REQUIRE(std::ranges::find(seen, ".") != seen.end());
         REQUIRE(std::ranges::find(seen, "info_1.txt") != seen.end());
 
@@ -68,7 +68,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture,
         {
           auto const position_at_exhaustion = fd.position();
 
-          auto one = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
+          auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
           auto result = fd.read_directory(one);
 
           REQUIRE(result);
diff --git a/kernel/kernel/filesystem/directory_listing_cursor.hpp b/kernel/kernel/vfs/directory_listing_cursor.hpp
index 5eb36c7a..544d1115 100644
--- a/kernel/kernel/filesystem/directory_listing_cursor.hpp
+++ b/kernel/kernel/vfs/directory_listing_cursor.hpp
@@ -1,10 +1,10 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DIRECTORY_LISTING_CURSOR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DIRECTORY_LISTING_CURSOR_HPP
+#ifndef TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_CURSOR_HPP
+#define TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_CURSOR_HPP
 
 #include <compare>
 #include <cstdint>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   //! A cursor used to keep track of positions in directory listings.
@@ -18,6 +18,6 @@ namespace kernel::filesystem
     std::uint64_t value;
   };
 
-};  // namespace kernel::filesystem
+};  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/directory_listing_entry.hpp b/kernel/kernel/vfs/directory_listing_entry.hpp
index f3dcf367..f636a6bf 100644
--- a/kernel/kernel/filesystem/directory_listing_entry.hpp
+++ b/kernel/kernel/vfs/directory_listing_entry.hpp
@@ -1,5 +1,5 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_DIRECTORY_LISTING_ENTRY_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_DIRECTORY_LISTING_ENTRY_HPP
+#ifndef TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_ENTRY_HPP
+#define TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_ENTRY_HPP
 
 #include <kapi/filesystem.hpp>
 
@@ -7,7 +7,7 @@
 
 #include <cstdint>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   //! An entry in a directory listing.
@@ -18,6 +18,6 @@ namespace kernel::filesystem
     std::uint64_t inode_number;
   };
 
-};  // namespace kernel::filesystem
+};  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/driver_registry.cpp b/kernel/kernel/vfs/driver_registry.cpp
index 9fa2d474..16d048bf 100644
--- a/kernel/kernel/filesystem/driver_registry.cpp
+++ b/kernel/kernel/vfs/driver_registry.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/driver_registry.hpp>
+#include <kernel/vfs/driver_registry.hpp>
 
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/system.hpp>
 
@@ -20,7 +20,7 @@
 #include <string_view>
 #include <utility>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   extern "C"
@@ -114,17 +114,17 @@ namespace kernel::filesystem
 
     if (candidates.empty())
     {
-      return kstd::failure(vfs_errc::unsupported_filesystem);
+      return kstd::failure(errc::unsupported_filesystem);
     }
 
     return candidates.front().driver;
   }
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
-namespace kernel::tests::filesystem::driver_registry
+namespace kernel::tests::vfs::driver_registry
 {
   auto deinit() -> void
   {
-    kernel::filesystem::instance.reset();
+    kernel::vfs::instance.reset();
   }
-}  // namespace kernel::tests::filesystem::driver_registry
\ No newline at end of file
+}  // namespace kernel::tests::vfs::driver_registry
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/driver_registry.hpp b/kernel/kernel/vfs/driver_registry.hpp
index 1a6cd47e..b463e086 100644
--- a/kernel/kernel/filesystem/driver_registry.hpp
+++ b/kernel/kernel/vfs/driver_registry.hpp
@@ -1,8 +1,8 @@
-#ifndef TEACHOS_KERNEL_DRIVER_REGISTRY_HPP
-#define TEACHOS_KERNEL_DRIVER_REGISTRY_HPP
+#ifndef TEACHOS_KERNEL_VFS_DRIVER_REGISTRY_HPP
+#define TEACHOS_KERNEL_VFS_DRIVER_REGISTRY_HPP
 
-#include <kernel/filesystem/filesystem.hpp>
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kstd/flat_map.hpp>
 #include <kstd/memory.hpp>
@@ -14,7 +14,7 @@
 #include <optional>
 #include <string_view>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   struct driver_descriptor
@@ -68,6 +68,6 @@ namespace kernel::filesystem
     kstd::flat_map<std::string_view, kstd::shared_ptr<filesystem>> m_drivers{};
   };
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
diff --git a/kernel/kernel/filesystem/error.cpp b/kernel/kernel/vfs/error.cpp
index 0d6ae01e..40f4cd79 100644
--- a/kernel/kernel/filesystem/error.cpp
+++ b/kernel/kernel/vfs/error.cpp
@@ -1,15 +1,15 @@
-#include <kernel/filesystem/error.hpp>
+#include <kernel/vfs/error.hpp>
 
 #include <kstd/system_error.hpp>
 
 #include <string_view>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   namespace
   {
-    struct vfs_category_t final : kstd::error_category
+    struct category_t final : kstd::error_category
     {
       [[nodiscard]] constexpr auto name() const noexcept -> std::string_view override
       {
@@ -18,45 +18,45 @@ namespace kernel::filesystem
 
       [[nodiscard]] constexpr auto message(int value) const noexcept -> std::string_view override
       {
-        switch (static_cast<vfs_errc>(value))
+        switch (static_cast<errc>(value))
         {
-          case vfs_errc::invalid_path:
+          case errc::invalid_path:
             return "invalid path";
-          case vfs_errc::no_such_file_or_directory:
+          case errc::no_such_file_or_directory:
             return "no such file or directory";
-          case vfs_errc::mount_point_not_found:
+          case errc::mount_point_not_found:
             return "mount point not found";
-          case vfs_errc::mount_busy:
+          case errc::mount_busy:
             return "mount point is busy";
-          case vfs_errc::has_child_mounts:
+          case errc::has_child_mounts:
             return "mount point has child mounts";
-          case vfs_errc::invalid_filesystem:
+          case errc::invalid_filesystem:
             return "invalid filesystem";
-          case vfs_errc::unmount_failed:
+          case errc::unmount_failed:
             return "unmount failed";
-          case vfs_errc::too_many_symbolic_link_levels:
+          case errc::too_many_symbolic_link_levels:
             return "too many symbolic link levels";
-          case vfs_errc::unsupported_filesystem:
+          case errc::unsupported_filesystem:
             return "unsupported filesystem";
-          case vfs_errc::invalid_file_descriptor:
+          case errc::invalid_file_descriptor:
             return "invalid file descriptor";
-          case vfs_errc::invalid_inode:
+          case errc::invalid_inode:
             return "invalid inode";
-          case vfs_errc::not_a_directory:
+          case errc::not_a_directory:
             return "not a directory";
-          case vfs_errc::is_a_directory:
+          case errc::is_a_directory:
             return "is a directory";
-          case vfs_errc::read_only_file_system:
+          case errc::read_only_file_system:
             return "readonly filesystem";
-          case vfs_errc::file_exists:
+          case errc::file_exists:
             return "file already exists";
-          case vfs_errc::no_such_device:
+          case errc::no_such_device:
             return "no such device";
-          case vfs_errc::invalid_argument:
+          case errc::invalid_argument:
             return "invalid argument";
-          case vfs_errc::not_mounted:
+          case errc::not_mounted:
             return "filesystem is not mounted";
-          case vfs_errc::invalid_driver_data:
+          case errc::invalid_driver_data:
             return "invalid driver data";
           default:
             return "unknown VFS error";
@@ -65,38 +65,38 @@ namespace kernel::filesystem
 
       [[nodiscard]] constexpr auto default_error_condition(int value) const noexcept -> kstd::error_condition override
       {
-        switch (static_cast<vfs_errc>(value))
+        switch (static_cast<errc>(value))
         {
-          case vfs_errc::invalid_path:
-          case vfs_errc::invalid_filesystem:
-          case vfs_errc::invalid_inode:
-          case vfs_errc::invalid_argument:
-          case vfs_errc::invalid_driver_data:
+          case errc::invalid_path:
+          case errc::invalid_filesystem:
+          case errc::invalid_inode:
+          case errc::invalid_argument:
+          case errc::invalid_driver_data:
             return make_error_condition(kstd::errc::invalid_argument);
-          case vfs_errc::no_such_file_or_directory:
-          case vfs_errc::mount_point_not_found:
+          case errc::no_such_file_or_directory:
+          case errc::mount_point_not_found:
             return make_error_condition(kstd::errc::no_such_file_or_directory);
-          case kernel::filesystem::vfs_errc::mount_busy:
-          case kernel::filesystem::vfs_errc::has_child_mounts:
-          case vfs_errc::unmount_failed:
+          case kernel::vfs::errc::mount_busy:
+          case kernel::vfs::errc::has_child_mounts:
+          case errc::unmount_failed:
             return make_error_condition(kstd::errc::device_or_resource_busy);
-          case vfs_errc::too_many_symbolic_link_levels:
+          case errc::too_many_symbolic_link_levels:
             return make_error_condition(kstd::errc::too_many_symbolic_link_levels);
-          case vfs_errc::unsupported_filesystem:
+          case errc::unsupported_filesystem:
             return make_error_condition(kstd::errc::not_supported);
-          case vfs_errc::invalid_file_descriptor:
+          case errc::invalid_file_descriptor:
             return make_error_condition(kstd::errc::bad_file_descriptor);
-          case vfs_errc::not_a_directory:
+          case errc::not_a_directory:
             return make_error_condition(kstd::errc::not_a_directory);
-          case vfs_errc::is_a_directory:
+          case errc::is_a_directory:
             return make_error_condition(kstd::errc::is_a_directory);
-          case vfs_errc::read_only_file_system:
+          case errc::read_only_file_system:
             return make_error_condition(kstd::errc::read_only_file_system);
-          case vfs_errc::file_exists:
+          case errc::file_exists:
             return make_error_condition(kstd::errc::file_exists);
-          case vfs_errc::no_such_device:
+          case errc::no_such_device:
             return make_error_condition(kstd::errc::no_such_device);
-          case vfs_errc::not_mounted:
+          case errc::not_mounted:
             return make_error_condition(kstd::errc::not_connected);
           default:
             return kstd::error_condition{value, *this};
@@ -105,9 +105,9 @@ namespace kernel::filesystem
     } constexpr vfs_category_instance{};
   }  // namespace
 
-  [[nodiscard]] auto vfs_category() noexcept -> kstd::error_category const &
+  [[nodiscard]] auto category() noexcept -> kstd::error_category const &
   {
     return vfs_category_instance;
   }
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
diff --git a/kernel/kernel/vfs/error.hpp b/kernel/kernel/vfs/error.hpp
new file mode 100644
index 00000000..ec1bd045
--- /dev/null
+++ b/kernel/kernel/vfs/error.hpp
@@ -0,0 +1,56 @@
+#ifndef TEACHOS_KERNEL_VFS_ERROR_HPP
+#define TEACHOS_KERNEL_VFS_ERROR_HPP
+
+#include <kstd/system_error.hpp>
+
+#include <type_traits>
+
+namespace kernel::vfs
+{
+
+  enum struct errc : int
+  {
+    invalid_path = 1,
+    no_such_file_or_directory,
+    mount_point_not_found,
+    mount_busy,
+    has_child_mounts,
+    invalid_filesystem,
+    unmount_failed,
+    too_many_symbolic_link_levels,
+    unsupported_filesystem,
+    invalid_file_descriptor,
+    invalid_inode,
+    not_a_directory,
+    is_a_directory,
+    read_only_file_system,
+    file_exists,
+    no_such_device,
+    invalid_argument,
+    not_mounted,
+    invalid_driver_data,
+  };
+
+  [[nodiscard]] auto category() noexcept -> kstd::error_category const &;
+
+  [[nodiscard]] constexpr auto inline make_error_code(errc error) noexcept -> kstd::error_code
+  {
+    return {static_cast<int>(error), category()};
+  }
+
+  [[nodiscard]] constexpr auto inline make_error_condition(errc error) noexcept -> kstd::error_condition
+  {
+    return {static_cast<int>(error), category()};
+  }
+
+}  // namespace kernel::vfs
+
+namespace kstd
+{
+  template<>
+  struct is_error_code_enum<kernel::vfs::errc> : std::true_type
+  {
+  };
+}  // namespace kstd
+
+#endif
diff --git a/kernel/kernel/filesystem/file_type_bindings.hpp b/kernel/kernel/vfs/file_type_bindings.hpp
index da8e4efc..d3fe84e3 100644
--- a/kernel/kernel/filesystem/file_type_bindings.hpp
+++ b/kernel/kernel/vfs/file_type_bindings.hpp
@@ -1,13 +1,13 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_FILE_TYPE_BINDINGS_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_FILE_TYPE_BINDINGS_HPP
+#ifndef TEACHOS_KERNEL_VFS_FILE_TYPE_BINDINGS_HPP
+#define TEACHOS_KERNEL_VFS_FILE_TYPE_BINDINGS_HPP
 
-#include <kernel/filesystem/reserved_numbers.hpp>
+#include <kernel/vfs/reserved_numbers.hpp>
 
 #include <kapi/filesystem.hpp>
 
 #include <array>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   //! A binding between a facet, a posix special file type
@@ -25,6 +25,6 @@ namespace kernel::filesystem
     file_type_binding{    kapi::filesystem::block_special_file::id,     kapi::filesystem::file_type::block_device},
   };
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
diff --git a/kernel/kernel/filesystem/filesystem.hpp b/kernel/kernel/vfs/filesystem.hpp
index f9fb2859..52abb437 100644
--- a/kernel/kernel/filesystem/filesystem.hpp
+++ b/kernel/kernel/vfs/filesystem.hpp
@@ -1,7 +1,7 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_FILESYSTEM_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_FILESYSTEM_HPP
+#ifndef TEACHOS_KERNEL_VFS_FILESYSTEM_HPP
+#define TEACHOS_KERNEL_VFS_FILESYSTEM_HPP
 
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -15,7 +15,7 @@
 #include <string_view>
 #include <utility>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   //! The base class for all filesystems.
   //!
@@ -72,6 +72,6 @@ namespace kernel::filesystem
         -> kstd::result<kstd::shared_ptr<inode>> = 0;
   };
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/inode.cpp b/kernel/kernel/vfs/inode.cpp
index 7b290479..ee7aa1e9 100644
--- a/kernel/kernel/filesystem/inode.cpp
+++ b/kernel/kernel/vfs/inode.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/inode.hpp>
+#include <kernel/vfs/inode.hpp>
 
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/error.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -14,7 +14,7 @@
 #include <span>
 #include <utility>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   auto inode::is_directory() const -> bool
   {
@@ -87,7 +87,7 @@ namespace kernel::filesystem
   auto inode::read_directory(directory_listing_cursor, std::span<directory_listing_entry>) const
       -> kstd::result<std::pair<std::size_t, directory_listing_cursor>>
   {
-    return kstd::failure(vfs_errc::not_a_directory);
+    return kstd::failure(errc::not_a_directory);
   }
 
   auto inode::owning_mount() const noexcept -> kstd::weak_ptr<mount>
@@ -100,4 +100,4 @@ namespace kernel::filesystem
     m_owning_mount = source;
   }
 
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/inode.hpp b/kernel/kernel/vfs/inode.hpp
index e7de9276..80657b92 100644
--- a/kernel/kernel/filesystem/inode.hpp
+++ b/kernel/kernel/vfs/inode.hpp
@@ -1,8 +1,8 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_INODE_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_INODE_HPP
+#ifndef TEACHOS_KERNEL_VFS_INODE_HPP
+#define TEACHOS_KERNEL_VFS_INODE_HPP
 
-#include <kernel/filesystem/directory_listing_cursor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
+#include <kernel/vfs/directory_listing_cursor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -15,7 +15,7 @@
 #include <span>
 #include <utility>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   struct mount;
 
@@ -137,6 +137,6 @@ namespace kernel::filesystem
   private:
     kstd::weak_ptr<mount> m_owning_mount{};
   };
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
diff --git a/kernel/kernel/filesystem/mount.cpp b/kernel/kernel/vfs/mount.cpp
index 7381a160..22496307 100644
--- a/kernel/kernel/filesystem/mount.cpp
+++ b/kernel/kernel/vfs/mount.cpp
@@ -1,7 +1,7 @@
-#include <kernel/filesystem/mount.hpp>
+#include <kernel/vfs/mount.hpp>
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/filesystem.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/filesystem.hpp>
 
 #include <kapi/system.hpp>
 
@@ -12,7 +12,7 @@
 #include <cstddef>
 #include <string_view>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   mount::mount(dentry_ptr const & mount_dentry, dentry_ptr const & root_dentry, filesystem_ptr const & fs,
                mount_ptr const & parent_mount, mount_ptr const & source_mount, kstd::shared_ptr<void> driver_data)
@@ -132,4 +132,4 @@ namespace kernel::filesystem
   {
     return m_ref_count;
   }
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/mount.hpp b/kernel/kernel/vfs/mount.hpp
index cc032874..b59d3de8 100644
--- a/kernel/kernel/filesystem/mount.hpp
+++ b/kernel/kernel/vfs/mount.hpp
@@ -1,8 +1,8 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_MOUNT_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_MOUNT_HPP
+#ifndef TEACHOS_KERNEL_VFS_MOUNT_HPP
+#define TEACHOS_KERNEL_VFS_MOUNT_HPP
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/filesystem.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/filesystem.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/result.hpp>
@@ -11,7 +11,7 @@
 #include <atomic>
 #include <cstddef>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   struct inode;
 
@@ -104,6 +104,6 @@ namespace kernel::filesystem
     kstd::shared_ptr<void> m_driver_data{};
     std::atomic_size_t m_ref_count{0};
   };
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
diff --git a/kernel/kernel/filesystem/mount.tests.cpp b/kernel/kernel/vfs/mount.tests.cpp
index a77134e5..bb56f3ef 100644
--- a/kernel/kernel/filesystem/mount.tests.cpp
+++ b/kernel/kernel/vfs/mount.tests.cpp
@@ -1,9 +1,9 @@
-#include <kernel/filesystem/mount.hpp>
+#include <kernel/vfs/mount.hpp>
 
-#include <kernel/filesystem/dentry.hpp>
 #include <kernel/test_support/cpu.hpp>
-#include <kernel/test_support/filesystem/filesystem.hpp>
-#include <kernel/test_support/filesystem/inode.hpp>
+#include <kernel/test_support/filesystems/filesystem.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
+#include <kernel/vfs/dentry.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/print.hpp>
@@ -17,12 +17,12 @@ SCENARIO("Mount construction", "[filesystem][mount]")
 {
   GIVEN("a filesystem and a root inode")
   {
-    auto fs = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode = kstd::make_shared<kernel::tests::filesystem::inode>();
+    auto fs = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_inode = kstd::make_shared<kernel::tests::filesystems::inode>();
 
     WHEN("attaching a mount with no mount point")
     {
-      auto mount = kernel::filesystem::mount::attach(nullptr, fs, root_inode, nullptr, nullptr, nullptr);
+      auto mount = kernel::vfs::mount::attach(nullptr, fs, root_inode, nullptr, nullptr, nullptr);
 
       THEN("the mount has the correct filesystem, root dentry, mount dentry, and mount path")
       {
@@ -45,7 +45,7 @@ SCENARIO("Mount construction", "[filesystem][mount]")
     {
       THEN("the constructor panics")
       {
-        REQUIRE_THROWS_AS((kernel::filesystem::mount::create(nullptr, nullptr, nullptr, nullptr, nullptr)),
+        REQUIRE_THROWS_AS((kernel::vfs::mount::create(nullptr, nullptr, nullptr, nullptr, nullptr)),
                           kernel::tests::cpu::halt);
       }
     }
@@ -56,14 +56,14 @@ SCENARIO("Mount reference counting", "[filesystem][mount]")
 {
   GIVEN("a filesystem and a root dentry")
   {
-    auto fs = kstd::make_shared<kernel::tests::filesystem::filesystem>();
-    auto root_inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto root_dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, root_inode, "/");
+    auto fs = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto root_dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, root_inode, "/");
 
     THEN("reference count can be incremented and decremented, the mount is ready to unmount when the reference "
          "count == 0")
     {
-      auto mount = kernel::filesystem::mount::create(root_dentry, fs, nullptr, nullptr, nullptr);
+      auto mount = kernel::vfs::mount::create(root_dentry, fs, nullptr, nullptr, nullptr);
       REQUIRE(mount);
 
       (*mount)->increment_ref_count();
@@ -85,7 +85,7 @@ SCENARIO("Mount reference counting", "[filesystem][mount]")
 
     THEN("decrementing reference count when it is already zero does not decrement it below zero")
     {
-      auto mount = kernel::filesystem::mount::create(root_dentry, fs, nullptr, nullptr, nullptr);
+      auto mount = kernel::vfs::mount::create(root_dentry, fs, nullptr, nullptr, nullptr);
 
       REQUIRE_THROWS_AS((*mount)->decrement_ref_count(), std::runtime_error);
       REQUIRE((*mount)->ref_count() == 0);
diff --git a/kernel/kernel/filesystem/mount_table.cpp b/kernel/kernel/vfs/mount_table.cpp
index d3f252b4..2b494040 100644
--- a/kernel/kernel/filesystem/mount_table.cpp
+++ b/kernel/kernel/vfs/mount_table.cpp
@@ -1,7 +1,7 @@
-#include <kernel/filesystem/mount_table.hpp>
+#include <kernel/vfs/mount_table.hpp>
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/mount.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/mount.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/vector.hpp>
@@ -10,7 +10,7 @@
 #include <ranges>
 #include <string_view>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   auto mount_table::has_child_mounts(kstd::shared_ptr<mount> const & parent_mount) const -> bool
   {
@@ -76,4 +76,4 @@ namespace kernel::filesystem
   {
     return std::ranges::find_last_if(m_mounts, [&](auto const & mount) { return mount->mount_path() == path; }).begin();
   }
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/mount_table.hpp b/kernel/kernel/vfs/mount_table.hpp
index 678a5927..86810a16 100644
--- a/kernel/kernel/filesystem/mount_table.hpp
+++ b/kernel/kernel/vfs/mount_table.hpp
@@ -1,14 +1,14 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_MOUNT_TABLE_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_MOUNT_TABLE_HPP
+#ifndef TEACHOS_KERNEL_VFS_MOUNT_TABLE_HPP
+#define TEACHOS_KERNEL_VFS_MOUNT_TABLE_HPP
 
-#include <kernel/filesystem/mount.hpp>
+#include <kernel/vfs/mount.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/vector.hpp>
 
 #include <string_view>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   //! A table managing all mounted filesystems.
   struct mount_table
@@ -47,6 +47,6 @@ namespace kernel::filesystem
 
     kstd::vector<kstd::shared_ptr<mount>> m_mounts;
   };
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
diff --git a/kernel/kernel/vfs/mount_table.tests.cpp b/kernel/kernel/vfs/mount_table.tests.cpp
new file mode 100644
index 00000000..e8f3ec4a
--- /dev/null
+++ b/kernel/kernel/vfs/mount_table.tests.cpp
@@ -0,0 +1,184 @@
+#include <kernel/vfs/mount_table.hpp>
+
+#include <kernel/test_support/filesystems/filesystem.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/mount.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/print.hpp>
+#include <kstd/vector.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <string_view>
+
+SCENARIO("Mount table construction", "[filesystem][mount_table]")
+{
+  GIVEN("an empty mount table")
+  {
+    kernel::vfs::mount_table table;
+
+    THEN("removing any mount returns mount_not_found")
+    {
+      REQUIRE(table.remove_mount("/") == kernel::vfs::mount_table::operation_result::mount_not_found);
+      REQUIRE(table.remove_mount("/any/path") == kernel::vfs::mount_table::operation_result::mount_not_found);
+    }
+  }
+}
+
+SCENARIO("Adding, finding and removing mounts in the mount table", "[filesystem][mount_table]")
+{
+  GIVEN("a mount table and some mounts")
+  {
+    kernel::vfs::mount_table table;
+
+    auto fs1 = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_dentry1 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount_dentry1 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount1 = kernel::vfs::mount::create(mount_dentry1, fs1, nullptr, nullptr, nullptr);
+
+    auto fs2 = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_dentry2 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount_dentry2 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/mnt");
+    auto mount2 = kernel::vfs::mount::create(mount_dentry2, fs2, nullptr, nullptr, nullptr);
+
+    table.add_mount(*mount1);
+    table.add_mount(*mount2);
+
+    THEN("dentry flags are set correctly for mounted dentries")
+    {
+      REQUIRE(mount_dentry1->has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
+      REQUIRE(mount_dentry2->has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
+    }
+
+    THEN("finding mounts by exact valid path returns the correct mount")
+    {
+      REQUIRE(table.find_mount("/") == mount1);
+      REQUIRE(table.find_mount("/mnt") == mount2);
+    }
+
+    THEN("finding mounts by exact invalid path returns null")
+    {
+      REQUIRE(table.find_mount("/nonexistent") == nullptr);
+      REQUIRE(table.find_mount("/mnt/file") == nullptr);
+    }
+
+    THEN("removing a mount that has no child mounts succeeds")
+    {
+      REQUIRE(table.remove_mount("/mnt") == kernel::vfs::mount_table::operation_result::removed);
+      REQUIRE_FALSE(root_dentry2->has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
+    }
+
+    THEN("removing a mount that does not exist returns mount_not_found")
+    {
+      REQUIRE(table.remove_mount("/nonexistent") == kernel::vfs::mount_table::operation_result::mount_not_found);
+    }
+  }
+
+  GIVEN("multiple mounts with the same path")
+  {
+    kernel::vfs::mount_table table;
+
+    auto fs1 = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_dentry1 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount_dentry1 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount1 = kernel::vfs::mount::create(mount_dentry1, fs1, nullptr, nullptr, nullptr);
+
+    auto fs2 = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_dentry2 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount_dentry2 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount2 = kernel::vfs::mount::create(mount_dentry2, fs2, nullptr, nullptr, nullptr);
+
+    table.add_mount(*mount1);
+    table.add_mount(*mount2);
+
+    THEN("finding mounts by exact valid path returns the correct mount")
+    {
+      REQUIRE(table.find_mount("/") == mount2);
+    }
+
+    THEN("removing the topmost mount with the same path succeeds")
+    {
+      REQUIRE(table.remove_mount("/") == kernel::vfs::mount_table::operation_result::removed);
+      REQUIRE_FALSE(root_dentry2->has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
+    }
+  }
+
+  GIVEN("a mount with child mounts")
+  {
+    kernel::vfs::mount_table table;
+
+    auto fs1 = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_dentry1 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount_dentry1 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount1 = kernel::vfs::mount::create(mount_dentry1, fs1, nullptr, nullptr, nullptr);
+
+    auto fs2 = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_dentry2 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount_dentry2 = kstd::make_shared<kernel::vfs::dentry>(
+        mount_dentry1, kstd::make_shared<kernel::tests::filesystems::inode>(), "mnt");
+    auto mount2 = kernel::vfs::mount::create(mount_dentry2, fs2, *mount1, nullptr, nullptr);
+
+    auto fs3 = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_dentry3 =
+        kstd::make_shared<kernel::vfs::dentry>(nullptr, kstd::make_shared<kernel::tests::filesystems::inode>(), "/");
+    auto mount_dentry3 = kstd::make_shared<kernel::vfs::dentry>(
+        mount_dentry2, kstd::make_shared<kernel::tests::filesystems::inode>(), "submnt");
+    auto mount3 = kernel::vfs::mount::create(mount_dentry3, fs3, *mount2, nullptr, nullptr);
+
+    table.add_mount(*mount1);
+    table.add_mount(*mount2);
+    table.add_mount(*mount3);
+
+    THEN("removing a mount with child mounts returns has_child_mounts")
+    {
+      REQUIRE(table.remove_mount("/") == kernel::vfs::mount_table::operation_result::has_child_mounts);
+      REQUIRE(table.remove_mount("/mnt") == kernel::vfs::mount_table::operation_result::has_child_mounts);
+    }
+
+    THEN("removing a leaf mount succeeds")
+    {
+      REQUIRE(table.remove_mount("/mnt/submnt") == kernel::vfs::mount_table::operation_result::removed);
+      REQUIRE_FALSE(root_dentry3->has_flag(kernel::vfs::dentry::dentry_flags::is_mount_point));
+    }
+  }
+}
+
+SCENARIO("Mount reference counting", "[filesystem][mount_table]")
+{
+  kernel::vfs::mount_table table;
+
+  GIVEN("a filesystem and a root dentry")
+  {
+    auto fs = kstd::make_shared<kernel::tests::filesystems::filesystem>();
+    auto root_inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto root_dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, root_inode, "/");
+
+    auto source_mount = kernel::vfs::mount::create(root_dentry, fs, nullptr, nullptr, nullptr);
+    auto mount = kernel::vfs::mount::create(root_dentry, fs, nullptr, *source_mount, nullptr);
+
+    THEN("reference count of source mount is incremented when a mount is added to the mount table and decremented when "
+         "the mount is removed")
+    {
+      REQUIRE((*source_mount)->ref_count() == 0);
+
+      table.add_mount(*mount);
+      REQUIRE((*source_mount)->ref_count() == 1);
+
+      REQUIRE(table.remove_mount("/") == kernel::vfs::mount_table::operation_result::removed);
+      REQUIRE((*source_mount)->ref_count() == 0);
+    }
+  }
+}
diff --git a/kernel/kernel/filesystem/open_file_descriptor.cpp b/kernel/kernel/vfs/open_file_descriptor.cpp
index d18ae141..44d55bb9 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.cpp
+++ b/kernel/kernel/vfs/open_file_descriptor.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/open_file_descriptor.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/error.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -14,7 +14,7 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   open_file_descriptor::open_file_descriptor(kstd::shared_ptr<dentry> const & dentry)
       : m_dentry(dentry)
@@ -27,22 +27,22 @@ namespace kernel::filesystem
 
   auto open_file_descriptor::read(std::span<std::byte>) -> kstd::result<kstd::bytes>
   {
-    return kstd::failure(vfs_errc::is_a_directory);
+    return kstd::failure(errc::is_a_directory);
   }
 
   auto open_file_descriptor::write(std::span<std::byte const>) -> kstd::result<kstd::bytes>
   {
-    return kstd::failure(vfs_errc::is_a_directory);
+    return kstd::failure(errc::is_a_directory);
   }
 
   auto open_file_descriptor::seek(kstd::offset, kapi::filesystem::seek_origin) -> kstd::result<kstd::bytes>
   {
-    return kstd::failure(vfs_errc::is_a_directory);
+    return kstd::failure(errc::is_a_directory);
   }
 
   auto open_file_descriptor::read_directory(std::span<directory_listing_entry>) -> kstd::result<std::size_t>
   {
-    return kstd::failure(vfs_errc::not_a_directory);
+    return kstd::failure(errc::not_a_directory);
   }
 
   auto open_file_descriptor::get_dentry() const -> kstd::shared_ptr<dentry> const &
@@ -50,4 +50,4 @@ namespace kernel::filesystem
     return m_dentry;
   }
 
-}  // namespace kernel::filesystem
\ No newline at end of file
+}  // namespace kernel::vfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/open_file_descriptor.hpp b/kernel/kernel/vfs/open_file_descriptor.hpp
index 3f3722b4..2fa27adc 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.hpp
+++ b/kernel/kernel/vfs/open_file_descriptor.hpp
@@ -1,8 +1,8 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_OPEN_FILE_DESCRIPTOR_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_OPEN_FILE_DESCRIPTOR_HPP
+#ifndef TEACHOS_KERNEL_VFS_OPEN_FILE_DESCRIPTOR_HPP
+#define TEACHOS_KERNEL_VFS_OPEN_FILE_DESCRIPTOR_HPP
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -13,7 +13,7 @@
 #include <cstddef>
 #include <span>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   //! An open file.
   //!
@@ -63,6 +63,6 @@ namespace kernel::filesystem
     kstd::shared_ptr<dentry> m_dentry;
   };
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/open_file_descriptor.tests.cpp b/kernel/kernel/vfs/open_file_descriptor.tests.cpp
index 2fbffbf8..861bddef 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.tests.cpp
+++ b/kernel/kernel/vfs/open_file_descriptor.tests.cpp
@@ -1,11 +1,11 @@
-#include <kernel/filesystem/open_file_descriptor.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
 
-#include <kernel/filesystem/byte_offset_file_descriptor.hpp>
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/directory_file_descriptor.hpp>
-#include <kernel/filesystem/directory_listing_entry.hpp>
-#include <kernel/filesystem/error.hpp>
-#include <kernel/test_support/filesystem/inode.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
+#include <kernel/vfs/byte_offset_file_descriptor.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/directory_file_descriptor.hpp>
+#include <kernel/vfs/directory_listing_entry.hpp>
+#include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -25,9 +25,9 @@ SCENARIO("open_file_descriptor's base defaults fail every operation, uncondition
 {
   GIVEN("a base open_file_descriptor constructed directly, not through a derived type")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "test_dentry");
-    auto fd = kernel::filesystem::open_file_descriptor{dentry};
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "test_dentry");
+    auto fd = kernel::vfs::open_file_descriptor{dentry};
 
     THEN("read fails as 'this is a directory', not silently succeeding with zero bytes")
     {
@@ -35,7 +35,7 @@ SCENARIO("open_file_descriptor's base defaults fail every operation, uncondition
       auto result = fd.read(buffer);
 
       REQUIRE_FALSE(result);
-      REQUIRE(result.error() == kernel::filesystem::vfs_errc::is_a_directory);
+      REQUIRE(result.error() == kernel::vfs::errc::is_a_directory);
     }
 
     THEN("write fails the same way")
@@ -44,7 +44,7 @@ SCENARIO("open_file_descriptor's base defaults fail every operation, uncondition
       auto result = fd.write(buffer);
 
       REQUIRE_FALSE(result);
-      REQUIRE(result.error() == kernel::filesystem::vfs_errc::is_a_directory);
+      REQUIRE(result.error() == kernel::vfs::errc::is_a_directory);
     }
 
     THEN("seek fails the same way")
@@ -52,17 +52,17 @@ SCENARIO("open_file_descriptor's base defaults fail every operation, uncondition
       auto result = fd.seek(kstd::offset{0}, kapi::filesystem::seek_origin::beginning);
 
       REQUIRE_FALSE(result);
-      REQUIRE(result.error() == kernel::filesystem::vfs_errc::is_a_directory);
+      REQUIRE(result.error() == kernel::vfs::errc::is_a_directory);
     }
 
     THEN("read_directory fails as 'this is not a directory' — the opposite error, and the only one of "
          "the four that's correct for it")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
       auto result = fd.read_directory(entries);
 
       REQUIRE_FALSE(result);
-      REQUIRE(result.error() == kernel::filesystem::vfs_errc::not_a_directory);
+      REQUIRE(result.error() == kernel::vfs::errc::not_a_directory);
     }
   }
 }
@@ -73,27 +73,27 @@ SCENARIO("Cross-type calls through open_file_descriptor fall through to the corr
 {
   GIVEN("a byte_offset_file_descriptor, accessed through a base pointer")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "test_dentry");
-    kstd::shared_ptr<kernel::filesystem::open_file_descriptor> fd =
-        kstd::make_shared<kernel::filesystem::byte_offset_file_descriptor>(dentry);
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "test_dentry");
+    kstd::shared_ptr<kernel::vfs::open_file_descriptor> fd =
+        kstd::make_shared<kernel::vfs::byte_offset_file_descriptor>(dentry);
 
     THEN("read_directory falls through to the base — byte_offset_file_descriptor never overrode it")
     {
-      auto entries = kstd::vector<kernel::filesystem::directory_listing_entry>(1);
+      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
       auto result = fd->read_directory(entries);
 
       REQUIRE_FALSE(result);
-      REQUIRE(result.error() == kernel::filesystem::vfs_errc::not_a_directory);
+      REQUIRE(result.error() == kernel::vfs::errc::not_a_directory);
     }
   }
 
   GIVEN("a directory_file_descriptor, accessed through a base pointer")
   {
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "test_dentry");
-    kstd::shared_ptr<kernel::filesystem::open_file_descriptor> fd =
-        kstd::make_shared<kernel::filesystem::directory_file_descriptor>(dentry);
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "test_dentry");
+    kstd::shared_ptr<kernel::vfs::open_file_descriptor> fd =
+        kstd::make_shared<kernel::vfs::directory_file_descriptor>(dentry);
 
     THEN("read/write/seek all fall through to the base — directory_file_descriptor never overrode any "
          "of them")
diff --git a/kernel/kernel/filesystem/open_file_table.cpp b/kernel/kernel/vfs/open_file_table.cpp
index dea504e4..286fa57b 100644
--- a/kernel/kernel/filesystem/open_file_table.cpp
+++ b/kernel/kernel/vfs/open_file_table.cpp
@@ -1,7 +1,7 @@
-#include <kernel/filesystem/open_file_table.hpp>
+#include <kernel/vfs/open_file_table.hpp>
 
-#include <kernel/filesystem/error.hpp>
-#include <kernel/filesystem/open_file_descriptor.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kapi/system.hpp>
 
@@ -15,10 +15,10 @@
 
 namespace
 {
-  constinit auto static global_open_file_table = std::optional<kernel::filesystem::open_file_table>{};
+  constinit auto static global_open_file_table = std::optional<kernel::vfs::open_file_table>{};
 }  // namespace
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   auto open_file_table::init() -> void
   {
@@ -45,7 +45,7 @@ namespace kernel::filesystem
   {
     if (!file_descriptor)
     {
-      return kstd::failure(vfs_errc::invalid_file_descriptor);
+      return kstd::failure(errc::invalid_file_descriptor);
     }
 
     auto it = std::ranges::find_if(m_open_files, [](auto const & open_file) { return open_file == nullptr; });
@@ -63,7 +63,7 @@ namespace kernel::filesystem
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
-      return kstd::failure(vfs_errc::invalid_file_descriptor);
+      return kstd::failure(errc::invalid_file_descriptor);
     }
 
     return kstd::success(m_open_files.at(fd));
@@ -73,18 +73,18 @@ namespace kernel::filesystem
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
-      return kstd::failure(vfs_errc::invalid_file_descriptor);
+      return kstd::failure(errc::invalid_file_descriptor);
     }
 
     m_open_files.at(fd) = nullptr;
     return kstd::success();
   }
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
-namespace kernel::tests::filesystem::open_file_table
+namespace kernel::tests::vfs::open_file_table
 {
   auto deinit() -> void
   {
     global_open_file_table.reset();
   }
-}  // namespace kernel::tests::filesystem::open_file_table
+}  // namespace kernel::tests::vfs::open_file_table
diff --git a/kernel/kernel/filesystem/open_file_table.hpp b/kernel/kernel/vfs/open_file_table.hpp
index ddc1ea16..10674ba7 100644
--- a/kernel/kernel/filesystem/open_file_table.hpp
+++ b/kernel/kernel/vfs/open_file_table.hpp
@@ -1,7 +1,7 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_OPEN_FILE_TABLE_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_OPEN_FILE_TABLE_HPP
+#ifndef TEACHOS_KERNEL_VFS_OPEN_FILE_TABLE_HPP
+#define TEACHOS_KERNEL_VFS_OPEN_FILE_TABLE_HPP
 
-#include <kernel/filesystem/open_file_descriptor.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/result.hpp>
@@ -10,7 +10,7 @@
 
 #include <cstddef>
 
-namespace kernel::filesystem
+namespace kernel::vfs
 {
   //! @brief A table for managing file descriptors in the filesystem.
   //!
@@ -52,6 +52,6 @@ namespace kernel::filesystem
 
     kstd::vector<kstd::shared_ptr<open_file_descriptor>> m_open_files{};
   };
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/open_file_table.tests.cpp b/kernel/kernel/vfs/open_file_table.tests.cpp
index 69188528..cae4a079 100644
--- a/kernel/kernel/filesystem/open_file_table.tests.cpp
+++ b/kernel/kernel/vfs/open_file_table.tests.cpp
@@ -1,8 +1,8 @@
-#include <kernel/filesystem/open_file_table.hpp>
+#include <kernel/vfs/open_file_table.hpp>
 
-#include <kernel/filesystem/dentry.hpp>
-#include <kernel/filesystem/open_file_descriptor.hpp>
-#include <kernel/test_support/filesystem/inode.hpp>
+#include <kernel/test_support/filesystems/inode.hpp>
+#include <kernel/vfs/dentry.hpp>
+#include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/print.hpp>
@@ -15,12 +15,12 @@ SCENARIO("Open file table add/get file", "[filesystem][open_file_table]")
 {
   GIVEN("a open file table and an open file descriptor")
   {
-    auto & table = kernel::filesystem::open_file_table::get();
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "test_dentry");
+    auto & table = kernel::vfs::open_file_table::get();
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "test_dentry");
 
-    auto file_descriptor_1 = kstd::make_shared<kernel::filesystem::open_file_descriptor>(dentry);
-    auto file_descriptor_2 = kstd::make_shared<kernel::filesystem::open_file_descriptor>(dentry);
+    auto file_descriptor_1 = kstd::make_shared<kernel::vfs::open_file_descriptor>(dentry);
+    auto file_descriptor_2 = kstd::make_shared<kernel::vfs::open_file_descriptor>(dentry);
 
     WHEN("adding the open file descriptor to the open file table")
     {
@@ -45,7 +45,7 @@ SCENARIO("Open file table add/get file", "[filesystem][open_file_table]")
 
   GIVEN("a invalid open file descriptor")
   {
-    auto & table = kernel::filesystem::open_file_table::get();
+    auto & table = kernel::vfs::open_file_table::get();
 
     THEN("adding a null file descriptor returns an error")
     {
@@ -65,10 +65,10 @@ SCENARIO("Open file table remove file", "[filesystem][open_file_table]")
 {
   GIVEN("a open file table with an open file descriptor")
   {
-    auto & table = kernel::filesystem::open_file_table::get();
-    auto inode = kstd::make_shared<kernel::tests::filesystem::inode>();
-    auto dentry = kstd::make_shared<kernel::filesystem::dentry>(nullptr, inode, "test_dentry");
-    auto file_descriptor = kstd::make_shared<kernel::filesystem::open_file_descriptor>(dentry);
+    auto & table = kernel::vfs::open_file_table::get();
+    auto inode = kstd::make_shared<kernel::tests::filesystems::inode>();
+    auto dentry = kstd::make_shared<kernel::vfs::dentry>(nullptr, inode, "test_dentry");
+    auto file_descriptor = kstd::make_shared<kernel::vfs::open_file_descriptor>(dentry);
     auto fd = table.add_file(file_descriptor);
 
     WHEN("removing the file descriptor using the file descriptor")
@@ -97,7 +97,7 @@ SCENARIO("Open file table remove file", "[filesystem][open_file_table]")
 
   GIVEN("an invalid file descriptor")
   {
-    auto & table = kernel::filesystem::open_file_table::get();
+    auto & table = kernel::vfs::open_file_table::get();
 
     THEN("removing a file with an out-of-bounds file descriptor does nothing")
     {
diff --git a/kernel/kernel/filesystem/path.hpp b/kernel/kernel/vfs/path.hpp
index 4dc0dbce..e3dbe8d5 100644
--- a/kernel/kernel/filesystem/path.hpp
+++ b/kernel/kernel/vfs/path.hpp
@@ -1,7 +1,7 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_PATH_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_PATH_HPP
+#ifndef TEACHOS_KERNEL_VFS_PATH_HPP
+#define TEACHOS_KERNEL_VFS_PATH_HPP
 
-#include <kernel/filesystem/constants.hpp>
+#include <kernel/vfs/constants.hpp>
 
 #include <kstd/string.hpp>
 
@@ -9,7 +9,7 @@
 #include <string_view>
 #include <utility>
 
-namespace kernel::filesystem::path
+namespace kernel::vfs::path
 {
 
   //! Check if the given path is within the maximum allowed length.
@@ -18,7 +18,7 @@ namespace kernel::filesystem::path
   //! @return @c true if the path length is valid, @c false otherwise.
   auto inline is_valid_path_length(std::string_view path) -> bool
   {
-    return path.length() < kernel::filesystem::constants::max_path_length;
+    return path.length() < kernel::vfs::constants::max_path_length;
   }
 
   //! Check if the given path is an absolute path.
@@ -92,6 +92,6 @@ namespace kernel::filesystem::path
     }
   }
 
-}  // namespace kernel::filesystem::path
+}  // namespace kernel::vfs::path
 
 #endif  // TEACHOS_KERNEL_FILESYSTEM_PATH_HPP
\ No newline at end of file
diff --git a/kernel/kernel/vfs/path.tests.cpp b/kernel/kernel/vfs/path.tests.cpp
new file mode 100644
index 00000000..5cdd7a81
--- /dev/null
+++ b/kernel/kernel/vfs/path.tests.cpp
@@ -0,0 +1,128 @@
+#include <kernel/vfs/path.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <algorithm>
+#include <string>
+#include <string_view>
+#include <vector>
+
+SCENARIO("path utilities", "[filesystem][path]")
+{
+  GIVEN("valid and invalid paths")
+  {
+    THEN("valid absolute paths are recognized as valid")
+    {
+      REQUIRE(kernel::vfs::path::is_valid_path("/valid/absolute/path"));
+      REQUIRE(kernel::vfs::path::is_valid_path("/"));
+    }
+
+    THEN("valid relative paths are recognized as valid")
+    {
+      REQUIRE(kernel::vfs::path::is_valid_path("valid/../relative/.././path"));
+      REQUIRE(kernel::vfs::path::is_valid_path("valid/relative/path"));
+      REQUIRE(kernel::vfs::path::is_valid_path("file.txt"));
+    }
+
+    THEN("invalid paths are recognized as invalid")
+    {
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_path(""));
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_path(std::string(4096, 'a')));
+    }
+
+    THEN("valid absolute paths are recognized as absolute")
+    {
+      REQUIRE(kernel::vfs::path::is_valid_absolute_path("/valid/absolute/path"));
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_absolute_path("valid/relative/path"));
+    }
+
+    THEN("invalid paths are not recognized as absolute")
+    {
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_absolute_path(""));
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_absolute_path(std::string(4096, 'a')));
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_absolute_path("invalid/absolute/path"));
+    }
+
+    THEN("valid relative paths are recognized as relative")
+    {
+      REQUIRE(kernel::vfs::path::is_valid_relative_path("valid/relative/path"));
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_relative_path("/valid/absolute/path"));
+    }
+
+    THEN("invalid paths are not recognized as relative")
+    {
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_relative_path(""));
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_relative_path(std::string(4096, 'a')));
+      REQUIRE_FALSE(kernel::vfs::path::is_valid_relative_path("/invalid/absolute/path"));
+    }
+  }
+
+  GIVEN("a valid path")
+  {
+    THEN("it can be split into components")
+    {
+      auto components = kernel::vfs::path::split("/a/b///c/d.txt");
+      std::vector<std::string_view> expected = {"a", "b", "c", "d.txt"};
+      REQUIRE(std::ranges::equal(components, expected));
+    }
+  }
+
+  GIVEN("file paths")
+  {
+    THEN("path is split into parent path and filename")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("/a/b/c/d.txt");
+      REQUIRE(parent == "/a/b/c");
+      REQUIRE(filename == "d.txt");
+    }
+
+    THEN("root path is split into root and empty filename")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("/");
+      REQUIRE(parent == "/");
+      REQUIRE(filename == "");
+    }
+
+    THEN("file directly under root is split correctly")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("/file.txt");
+      REQUIRE(parent == "/");
+      REQUIRE(filename == "file.txt");
+    }
+
+    THEN("filename without parent path is split into empty parent and filename")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("file.txt");
+      REQUIRE(parent == "");
+      REQUIRE(filename == "file.txt");
+    }
+
+    THEN("path with trailing slash is split correctly")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("/a/b/c/");
+      REQUIRE(parent == "/a/b");
+      REQUIRE(filename == "c");
+    }
+
+    THEN("single component with trailing slash has root as parent")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("/a/");
+      REQUIRE(parent == "/");
+      REQUIRE(filename == "a");
+    }
+
+    THEN("relative path is split into relative parent and filename")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("a/b/c.txt");
+      REQUIRE(parent == "a/b");
+      REQUIRE(filename == "c.txt");
+    }
+
+    THEN("an empty path is split into empty parent and filename")
+    {
+      auto [parent, filename] = kernel::vfs::path::split_into_path_and_filename("");
+      REQUIRE(parent == "");
+      REQUIRE(filename == "");
+    }
+  }
+}
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/reserved_numbers.hpp b/kernel/kernel/vfs/reserved_numbers.hpp
index 871d93f8..2632b4e6 100644
--- a/kernel/kernel/filesystem/reserved_numbers.hpp
+++ b/kernel/kernel/vfs/reserved_numbers.hpp
@@ -1,10 +1,10 @@
-#ifndef TEACHOS_KERNEL_FILESYSTEM_RESERVED_NUMBERS_HPP
-#define TEACHOS_KERNEL_FILESYSTEM_RESERVED_NUMBERS_HPP
+#ifndef TEACHOS_KERNEL_VFS_RESERVED_NUMBERS_HPP
+#define TEACHOS_KERNEL_VFS_RESERVED_NUMBERS_HPP
 
 #include <cstdint>
 
 //! Constants defining major numbers used in the VFS layer.
-namespace kernel::filesystem
+namespace kernel::vfs
 {
 
   namespace block_major_numbers
@@ -31,6 +31,6 @@ namespace kernel::filesystem
     constexpr auto inline zero = std::uint8_t{5};
   }  // namespace character_minor_numbers
 
-}  // namespace kernel::filesystem
+}  // namespace kernel::vfs
 
 #endif