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

Refactor

See merge request teachos/kernel!18

29 files changed, 278 insertions, 279 deletions

diff --git a/kernel/src/devices/block_device.cpp b/kernel/src/devices/block_device.cpp
index 3402814..cfe2eb2 100644
--- a/kernel/src/devices/block_device.cpp
+++ b/kernel/src/devices/block_device.cpp
@@ -8,7 +8,7 @@
 
 #include <cstddef>
 
-namespace devices
+namespace kernel::devices
 {
   block_device::block_device(size_t major, size_t minor, kstd::string const & name, size_t block_size)
       : device(major, minor, name)
@@ -40,4 +40,4 @@ namespace devices
   {
     return size();
   }
-}  // namespace devices
\ No newline at end of file
+}  // namespace kernel::devices
\ No newline at end of file
diff --git a/kernel/src/devices/block_device_utils.cpp b/kernel/src/devices/block_device_utils.cpp
index 9d3af1b..5469087 100644
--- a/kernel/src/devices/block_device_utils.cpp
+++ b/kernel/src/devices/block_device_utils.cpp
@@ -12,7 +12,7 @@
 #include <algorithm>
 #include <cstddef>
 
-namespace devices::block_device_utils
+namespace kernel::devices::block_device_utils
 {
 
   using block_op = void (*)(size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
@@ -100,4 +100,4 @@ namespace devices::block_device_utils
                           });
   }
 
-}  // namespace devices::block_device_utils
\ No newline at end of file
+}  // namespace kernel::devices::block_device_utils
\ No newline at end of file
diff --git a/kernel/src/devices/device.cpp b/kernel/src/devices/device.cpp
index 287f14b..1e7589e 100644
--- a/kernel/src/devices/device.cpp
+++ b/kernel/src/devices/device.cpp
@@ -4,7 +4,7 @@
 
 #include <cstddef>
 
-namespace devices
+namespace kernel::devices
 {
   device::device(size_t major, size_t minor, kstd::string const & name)
       : m_major(major)
@@ -26,4 +26,4 @@ namespace devices
   {
     return m_name;
   }
-}  // namespace devices
\ No newline at end of file
+}  // namespace kernel::devices
\ No newline at end of file
diff --git a/kernel/src/devices/storage/controller.cpp b/kernel/src/devices/storage/controller.cpp
new file mode 100644
index 0000000..46c45e4
--- /dev/null
+++ b/kernel/src/devices/storage/controller.cpp
@@ -0,0 +1,44 @@
+#include "kernel/devices/storage/controller.hpp"
+
+#include "kernel/devices/device.hpp"
+
+#include <kstd/memory>
+#include <kstd/vector>
+
+#include <algorithm>
+#include <cstddef>
+
+namespace kernel::devices::storage
+{
+  auto controller::set_ids(size_t major, size_t minors_per_dev) -> void
+  {
+    m_major = major;
+    m_minors_per_device = minors_per_dev;
+  }
+
+  auto controller::major() const -> size_t
+  {
+    return m_major;
+  }
+
+  auto controller::device_by_minor(size_t minor) const -> kstd::shared_ptr<devices::device>
+  {
+    auto it = std::ranges::find_if(m_devices, [minor](auto const & device) { return device->minor() == minor; });
+
+    if (it != m_devices.end())
+    {
+      return *it;
+    }
+    return nullptr;
+  }
+
+  auto controller::devices_count() const -> size_t
+  {
+    return m_devices.size();
+  }
+
+  auto controller::all_devices() const -> kstd::vector<kstd::shared_ptr<devices::device>> const &
+  {
+    return m_devices;
+  }
+}  // namespace kernel::devices::storage
\ No newline at end of file
diff --git a/kernel/src/devices/storage/storage_management.cpp b/kernel/src/devices/storage/management.cpp
index 56216b0..62c0ce4 100644
--- a/kernel/src/devices/storage/storage_management.cpp
+++ b/kernel/src/devices/storage/management.cpp
@@ -1,11 +1,11 @@
-#include "kernel/devices/storage/storage_management.hpp"
+#include "kernel/devices/storage/management.hpp"
 
 #include "kapi/boot_modules.hpp"
 #include "kapi/system.hpp"
 
 #include "kernel/devices/device.hpp"
-#include "kernel/devices/storage/ram_disk/ram_disk_controller.hpp"
-#include "kernel/devices/storage/storage_controller.hpp"
+#include "kernel/devices/storage/controller.hpp"
+#include "kernel/devices/storage/ram_disk/controller.hpp"
 
 #include <kstd/memory>
 #include <kstd/vector>
@@ -14,7 +14,7 @@
 #include <cstddef>
 #include <optional>
 
-namespace devices::storage
+namespace kernel::devices::storage
 {
   namespace
   {
@@ -22,25 +22,25 @@ namespace devices::storage
     constexpr size_t static START_MAJOR = 1;
     constinit size_t static next_free_major = START_MAJOR;
 
-    constinit auto static active_storage_management = std::optional<storage_management>{};
+    constinit auto static active_storage_management = std::optional<management>{};
   }  // namespace
 
-  auto storage_management::init() -> void
+  auto management::init() -> void
   {
     if (active_storage_management)
     {
       kapi::system::panic("[DEVICES] Storage management has already been initialized.");
     }
-    active_storage_management.emplace(storage_management{});
+    active_storage_management.emplace(management{});
 
     auto current_ram_disk_controller =
-        kstd::make_shared<ram_disk::ram_disk_controller>(&kapi::boot_modules::get_boot_module_registry());
+        kstd::make_shared<ram_disk::controller>(&kapi::boot_modules::get_boot_module_registry());
     active_storage_management->add_controller(current_ram_disk_controller);
 
     std::ranges::for_each(active_storage_management->m_controllers, [](auto controller) { controller->probe(); });
   }
 
-  auto storage_management::get() -> storage_management &
+  auto management::get() -> management &
   {
     if (!active_storage_management)
     {
@@ -50,18 +50,18 @@ namespace devices::storage
     return *active_storage_management;
   }
 
-  auto storage_management::add_controller(kstd::shared_ptr<storage_controller> const & controller) -> void
+  auto management::add_controller(kstd::shared_ptr<controller> const & controller) -> void
   {
     controller->set_ids(next_free_major++, MINORS_PER_DEVICE);
     m_controllers.push_back(controller);
   }
 
-  auto storage_management::all_controllers() const -> kstd::vector<kstd::shared_ptr<storage_controller>> const &
+  auto management::all_controllers() const -> kstd::vector<kstd::shared_ptr<controller>> const &
   {
     return m_controllers;
   }
 
-  auto storage_management::device_by_major_minor(size_t major, size_t minor) -> kstd::shared_ptr<device>
+  auto management::device_by_major_minor(size_t major, size_t minor) -> kstd::shared_ptr<device>
   {
     kstd::shared_ptr<device> found = nullptr;
 
@@ -77,9 +77,9 @@ namespace devices::storage
     return found;
   }
 
-  auto storage_management::determine_boot_device() -> kstd::shared_ptr<device>
+  auto management::determine_boot_device() -> kstd::shared_ptr<device>
   {
     return device_by_major_minor(START_MAJOR, 0);
   }
 
-}  // namespace devices::storage
\ No newline at end of file
+}  // namespace kernel::devices::storage
\ No newline at end of file
diff --git a/kernel/src/devices/storage/ram_disk/controller.cpp b/kernel/src/devices/storage/ram_disk/controller.cpp
new file mode 100644
index 0000000..040e61f
--- /dev/null
+++ b/kernel/src/devices/storage/ram_disk/controller.cpp
@@ -0,0 +1,27 @@
+#include "kernel/devices/storage/ram_disk/controller.hpp"
+
+#include "kapi/boot_module/boot_module_registry.hpp"
+
+#include "kernel/devices/storage/ram_disk/device.hpp"
+
+#include <kstd/memory>
+
+#include <algorithm>
+#include <cstddef>
+
+namespace kernel::devices::storage::ram_disk
+{
+  controller::controller(kapi::boot_modules::boot_module_registry const * registry)
+      : m_boot_module_registry(registry)
+  {}
+
+  auto controller::probe() -> void
+  {
+    size_t current_device_index = 0;
+
+    std::ranges::for_each(*m_boot_module_registry, [this, &current_device_index](auto const & module) {
+      auto const minor = current_device_index++ * m_minors_per_device;
+      m_devices.push_back(kstd::make_shared<device>(module, m_major, minor));
+    });
+  }
+}  // namespace kernel::devices::storage::ram_disk
\ No newline at end of file
diff --git a/kernel/src/devices/storage/ram_disk/ram_disk_device.cpp b/kernel/src/devices/storage/ram_disk/device.cpp
index bf329cb..5116c93 100644
--- a/kernel/src/devices/storage/ram_disk/ram_disk_device.cpp
+++ b/kernel/src/devices/storage/ram_disk/device.cpp
@@ -1,28 +1,27 @@
-#include "kernel/devices/storage/ram_disk/ram_disk_device.hpp"
-
 #include "kapi/boot_module/boot_module.hpp"
 #include "kapi/system.hpp"
 
 #include "kernel/devices/block_device.hpp"
+#include "kernel/devices/storage/ram_disk/device.hpp"
 
 #include <kstd/cstring>
 #include <kstd/string>
 
 #include <cstddef>
 
-namespace devices::storage::ram_disk
+namespace kernel::devices::storage::ram_disk
 {
   namespace
   {
     constexpr size_t RAM_DISK_BLOCK_SIZE = 512uz;
   }  // namespace
 
-  ram_disk_device::ram_disk_device(kapi::boot_modules::boot_module const & module, size_t major, size_t minor)
+  device::device(kapi::boot_modules::boot_module const & module, size_t major, size_t minor)
       : block_device(major, minor, "ram" + kstd::to_string(minor), RAM_DISK_BLOCK_SIZE)
       , m_boot_module(module)
   {}
 
-  auto ram_disk_device::read_block(size_t block_index, void * buffer) const -> void
+  auto device::read_block(size_t block_index, void * buffer) const -> void
   {
     if (buffer == nullptr)
     {
@@ -43,7 +42,7 @@ namespace devices::storage::ram_disk
     }
   }
 
-  auto ram_disk_device::write_block(size_t block_index, void const * buffer) -> void
+  auto device::write_block(size_t block_index, void const * buffer) -> void
   {
     if (buffer == nullptr)
     {
@@ -59,8 +58,8 @@ namespace devices::storage::ram_disk
     }
   }
 
-  auto ram_disk_device::size() const -> size_t
+  auto device::size() const -> size_t
   {
     return m_boot_module.size;
   }
-}  // namespace devices::storage::ram_disk
\ No newline at end of file
+}  // namespace kernel::devices::storage::ram_disk
\ No newline at end of file
diff --git a/kernel/src/devices/storage/ram_disk/ram_disk_controller.cpp b/kernel/src/devices/storage/ram_disk/ram_disk_controller.cpp
deleted file mode 100644
index f3e9f70..0000000
--- a/kernel/src/devices/storage/ram_disk/ram_disk_controller.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "kernel/devices/storage/ram_disk/ram_disk_controller.hpp"
-
-#include "kapi/boot_module/boot_module_registry.hpp"
-
-#include "kernel/devices/storage/ram_disk/ram_disk_device.hpp"
-
-#include <kstd/memory>
-
-#include <algorithm>
-#include <cstddef>
-
-namespace devices::storage::ram_disk
-{
-  ram_disk_controller::ram_disk_controller(kapi::boot_modules::boot_module_registry const * registry)
-      : m_boot_module_registry(registry)
-  {}
-
-  auto ram_disk_controller::probe() -> void
-  {
-    size_t current_device_index = 0;
-
-    std::ranges::for_each(*m_boot_module_registry, [this, &current_device_index](auto const & module) {
-      auto const minor = current_device_index++ * m_minors_per_device;
-      m_devices.push_back(kstd::make_shared<ram_disk_device>(module, m_major, minor));
-    });
-  }
-}  // namespace devices::storage::ram_disk
\ No newline at end of file
diff --git a/kernel/src/devices/storage/storage_controller.cpp b/kernel/src/devices/storage/storage_controller.cpp
deleted file mode 100644
index e415436..0000000
--- a/kernel/src/devices/storage/storage_controller.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "kernel/devices/storage/storage_controller.hpp"
-
-#include "kernel/devices/device.hpp"
-
-#include <kstd/memory>
-#include <kstd/vector>
-
-#include <algorithm>
-#include <cstddef>
-
-namespace devices::storage
-{
-  auto storage_controller::set_ids(size_t major, size_t minors_per_dev) -> void
-  {
-    m_major = major;
-    m_minors_per_device = minors_per_dev;
-  }
-
-  auto storage_controller::major() const -> size_t
-  {
-    return m_major;
-  }
-
-  auto storage_controller::device_by_minor(size_t minor) const -> kstd::shared_ptr<devices::device>
-  {
-    auto it = std::ranges::find_if(m_devices, [minor](auto const & device) { return device->minor() == minor; });
-
-    if (it != m_devices.end())
-    {
-      return *it;
-    }
-    return nullptr;
-  }
-
-  auto storage_controller::devices_count() const -> size_t
-  {
-    return m_devices.size();
-  }
-
-  auto storage_controller::all_devices() const -> kstd::vector<kstd::shared_ptr<devices::device>> const &
-  {
-    return m_devices;
-  }
-}  // namespace devices::storage
\ No newline at end of file
diff --git a/kernel/src/filesystem/dentry.cpp b/kernel/src/filesystem/dentry.cpp
index 76949f2..2f99e91 100644
--- a/kernel/src/filesystem/dentry.cpp
+++ b/kernel/src/filesystem/dentry.cpp
@@ -10,7 +10,7 @@
 #include <cstdint>
 #include <string_view>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   dentry::dentry(kstd::shared_ptr<dentry> const & parent, kstd::shared_ptr<inode> const & node, std::string_view name)
       : m_name(name)
@@ -58,4 +58,4 @@ namespace filesystem
   {
     return (m_flags & static_cast<uint32_t>(flag)) != 0;
   }
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/devfs/devfs_root_inode.cpp b/kernel/src/filesystem/devfs/devfs_root_inode.cpp
deleted file mode 100644
index 53441b0..0000000
--- a/kernel/src/filesystem/devfs/devfs_root_inode.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "kernel/filesystem/devfs/devfs_root_inode.hpp"
-
-#include "kernel/filesystem/inode.hpp"
-
-#include <cstddef>
-
-namespace filesystem::devfs
-{
-  devfs_root_inode::devfs_root_inode()
-      : inode(inode_kind::directory)
-  {}
-
-  auto devfs_root_inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
-  {
-    return 0;
-  }
-
-  auto devfs_root_inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
-  {
-    return 0;
-  }
-}  // namespace filesystem::devfs
\ No newline at end of file
diff --git a/kernel/src/filesystem/devfs/devfs_filesystem.cpp b/kernel/src/filesystem/devfs/filesystem.cpp
index c4cd81a..94c9b05 100644
--- a/kernel/src/filesystem/devfs/devfs_filesystem.cpp
+++ b/kernel/src/filesystem/devfs/filesystem.cpp
@@ -1,8 +1,8 @@
-#include "kernel/filesystem/devfs/devfs_filesystem.hpp"
+#include "kernel/filesystem/devfs/filesystem.hpp"
 
 #include "kernel/devices/device.hpp"
-#include "kernel/devices/storage/storage_management.hpp"
-#include "kernel/filesystem/devfs/devfs_root_inode.hpp"
+#include "kernel/devices/storage/management.hpp"
+#include "kernel/filesystem/devfs/inode.hpp"
 #include "kernel/filesystem/device_inode.hpp"
 #include "kernel/filesystem/inode.hpp"
 
@@ -11,18 +11,18 @@
 #include <algorithm>
 #include <string_view>
 
-namespace filesystem::devfs
+namespace kernel::filesystem::devfs
 {
-  auto devfs_filesystem::mount(kstd::shared_ptr<devices::device> const &) -> int
+  auto filesystem::mount(kstd::shared_ptr<devices::device> const &) -> int
   {
-    m_root_inode = kstd::make_shared<devfs_root_inode>();
+    m_root_inode = kstd::make_shared<inode>();
     build_device_inode_table();
 
     return 0;
   }
 
-  auto devfs_filesystem::lookup(kstd::shared_ptr<inode> const & parent, std::string_view name)
-      -> kstd::shared_ptr<inode>
+  auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name)
+      -> kstd::shared_ptr<kernel::filesystem::inode>
   {
     if (!parent || !parent->is_directory())
     {
@@ -45,14 +45,14 @@ namespace filesystem::devfs
     return (it != m_inodes.end()) ? *it : nullptr;
   }
 
-  auto devfs_filesystem::build_device_inode_table() -> void
+  auto filesystem::build_device_inode_table() -> void
   {
     m_inodes.clear();
 
-    auto storage_mgmt = devices::storage::storage_management::get();
+    auto storage_mgmt = devices::storage::management::get();
     std::ranges::for_each(storage_mgmt.all_controllers(), [&](auto const & controller) {
       std::ranges::for_each(controller->all_devices(),
                             [&](auto const & device) { m_inodes.push_back(kstd::make_shared<device_inode>(device)); });
     });
   }
-}  // namespace filesystem::devfs
\ No newline at end of file
+}  // namespace kernel::filesystem::devfs
\ No newline at end of file
diff --git a/kernel/src/filesystem/devfs/inode.cpp b/kernel/src/filesystem/devfs/inode.cpp
new file mode 100644
index 0000000..52cf6fa
--- /dev/null
+++ b/kernel/src/filesystem/devfs/inode.cpp
@@ -0,0 +1,22 @@
+#include "kernel/filesystem/devfs/inode.hpp"
+
+#include "kernel/filesystem/inode.hpp"
+
+#include <cstddef>
+
+namespace kernel::filesystem::devfs
+{
+  inode::inode()
+      : kernel::filesystem::inode(inode_kind::directory)
+  {}
+
+  auto inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
+  {
+    return 0;
+  }
+
+  auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
+  {
+    return 0;
+  }
+}  // namespace kernel::filesystem::devfs
\ No newline at end of file
diff --git a/kernel/src/filesystem/device_inode.cpp b/kernel/src/filesystem/device_inode.cpp
index da062fc..d574d8f 100644
--- a/kernel/src/filesystem/device_inode.cpp
+++ b/kernel/src/filesystem/device_inode.cpp
@@ -12,7 +12,7 @@
 
 #include <cstddef>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   device_inode::device_inode(kstd::shared_ptr<devices::device> const & device)
       : inode(inode_kind::device)
@@ -53,4 +53,4 @@ namespace filesystem
     return m_device;
   }
 
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/ext2/ext2_inode.cpp b/kernel/src/filesystem/ext2/ext2_inode.cpp
deleted file mode 100644
index 3cc0fb2..0000000
--- a/kernel/src/filesystem/ext2/ext2_inode.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "kernel/filesystem/ext2/ext2_inode.hpp"
-
-#include "kernel/filesystem/inode.hpp"
-
-#include <cstddef>
-
-namespace filesystem::ext2
-{
-  ext2_inode::ext2_inode()
-      : inode(inode_kind::regular)
-  {}
-
-  auto ext2_inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
-  {
-    // TODO BA-FS26 implement
-    return 0;
-  }
-
-  auto ext2_inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
-  {
-    // TODO BA-FS26 implement
-    return 0;
-  }
-}  // namespace filesystem::ext2
\ No newline at end of file
diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/filesystem.cpp
index ea6fe0d..d951158 100644
--- a/kernel/src/filesystem/ext2/ext2_filesystem.cpp
+++ b/kernel/src/filesystem/ext2/filesystem.cpp
@@ -1,9 +1,9 @@
-#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+#include "kernel/filesystem/ext2/filesystem.hpp"
 
 #include "kernel/devices/block_device_utils.hpp"
 #include "kernel/devices/device.hpp"
-#include "kernel/filesystem/ext2/ext2_inode.hpp"
-#include "kernel/filesystem/ext2/ext2_superblock.hpp"
+#include "kernel/filesystem/ext2/inode.hpp"
+#include "kernel/filesystem/ext2/superblock.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/inode.hpp"
 
@@ -13,7 +13,7 @@
 #include <cstdint>
 #include <string_view>
 
-namespace filesystem::ext2
+namespace kernel::filesystem::ext2
 {
   namespace
   {
@@ -34,31 +34,31 @@ namespace filesystem::ext2
     //   return (mode & S_IFMT) == S_IFDIR;
     // }
 
-    // auto get_block_size(ext2_superblock const & superblock) -> size_t
+    // auto get_block_size(superblock const & superblock) -> size_t
     // {
     //   return 1024U << superblock.log_block_size;
     // }
 
-    // auto get_inode_size(ext2_superblock const & superblock) -> size_t
+    // auto get_inode_size(superblock const & superblock) -> size_t
     // {
     //   return superblock.rev_level == 0 ? 128 : superblock.inode_size;
     // }
   }  // namespace
 
-  auto ext2_filesystem::mount(kstd::shared_ptr<devices::device> const & device) -> int
+  auto filesystem::mount(kstd::shared_ptr<devices::device> const & device) -> int
   {
-    filesystem::mount(device);  // TODO BA-FS26 error handling?
+    kernel::filesystem::filesystem::mount(device);  // TODO BA-FS26 error handling?
     // TODO BA-FS26 load proper root inode from ext2 metadata
     // m_root_inode = inode{inode_kind::directory};
 
     // TODO BA-FS26 implement
-    m_root_inode = kstd::make_shared<ext2_inode>();
+    m_root_inode = kstd::make_shared<inode>();
     // devices::block_device_utils::read(device, nullptr, 0, 0);  // TODO BA-FS26 just for testing
     return 0;
   }
 
-  auto ext2_filesystem::lookup(kstd::shared_ptr<inode> const & /*parent*/, std::string_view name)
-      -> kstd::shared_ptr<inode>
+  auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & /*parent*/, std::string_view name)
+      -> kstd::shared_ptr<kernel::filesystem::inode>
   {
     // TODO BA-FS26 implement ext2 directory traversal and inode loading
     if (name == "dev")
@@ -67,6 +67,6 @@ namespace filesystem::ext2
       return nullptr;
     }
 
-    return kstd::make_shared<ext2_inode>();
+    return kstd::make_shared<inode>();
   }
-}  // namespace filesystem::ext2
+}  // namespace kernel::filesystem::ext2
diff --git a/kernel/src/filesystem/ext2/inode.cpp b/kernel/src/filesystem/ext2/inode.cpp
new file mode 100644
index 0000000..b75969a
--- /dev/null
+++ b/kernel/src/filesystem/ext2/inode.cpp
@@ -0,0 +1,24 @@
+#include "kernel/filesystem/ext2/inode.hpp"
+
+#include "kernel/filesystem/inode.hpp"
+
+#include <cstddef>
+
+namespace kernel::filesystem::ext2
+{
+  inode::inode()
+      : kernel::filesystem::inode(inode_kind::regular)
+  {}
+
+  auto inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
+  {
+    // TODO BA-FS26 implement
+    return 0;
+  }
+
+  auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
+  {
+    // TODO BA-FS26 implement
+    return 0;
+  }
+}  // namespace kernel::filesystem::ext2
\ No newline at end of file
diff --git a/kernel/src/filesystem/file_descriptor_table.cpp b/kernel/src/filesystem/file_descriptor_table.cpp
index 6eb3845..287aea2 100644
--- a/kernel/src/filesystem/file_descriptor_table.cpp
+++ b/kernel/src/filesystem/file_descriptor_table.cpp
@@ -10,7 +10,7 @@
 #include <cstddef>
 #include <optional>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   namespace
   {
@@ -87,4 +87,4 @@ namespace filesystem
 
     m_open_files.at(index) = nullptr;
   }
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/filesystem.cpp b/kernel/src/filesystem/filesystem.cpp
index 0e33d95..c891d00 100644
--- a/kernel/src/filesystem/filesystem.cpp
+++ b/kernel/src/filesystem/filesystem.cpp
@@ -5,7 +5,7 @@
 
 #include <kstd/memory>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   auto filesystem::mount(kstd::shared_ptr<devices::device> const & device) -> int
   {
@@ -21,4 +21,4 @@ namespace filesystem
   {
     return m_root_inode;
   }
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/inode.cpp b/kernel/src/filesystem/inode.cpp
index de3282f..1cbead8 100644
--- a/kernel/src/filesystem/inode.cpp
+++ b/kernel/src/filesystem/inode.cpp
@@ -1,6 +1,6 @@
 #include "kernel/filesystem/inode.hpp"
 
-namespace filesystem
+namespace kernel::filesystem
 {
   inode::inode(inode_kind kind)
       : m_kind(kind)
@@ -20,4 +20,4 @@ namespace filesystem
   {
     return m_kind == inode_kind::device;
   }
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/mount.cpp b/kernel/src/filesystem/mount.cpp
index afc07fa..f9e709c 100644
--- a/kernel/src/filesystem/mount.cpp
+++ b/kernel/src/filesystem/mount.cpp
@@ -10,7 +10,7 @@
 
 #include <string_view>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   mount::mount(kstd::shared_ptr<dentry> const & mount_dentry, kstd::shared_ptr<dentry> const & root_dentry,
                kstd::shared_ptr<filesystem> const & fs, std::string_view mount_path)
@@ -44,4 +44,4 @@ namespace filesystem
   {
     return m_mount_path.view();
   }
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/mount_table.cpp b/kernel/src/filesystem/mount_table.cpp
index b9e57d4..737434e 100644
--- a/kernel/src/filesystem/mount_table.cpp
+++ b/kernel/src/filesystem/mount_table.cpp
@@ -7,7 +7,7 @@
 #include <cstddef>
 #include <string_view>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   void mount_table::add_mount(kstd::shared_ptr<mount> mount)
   {
@@ -35,4 +35,4 @@ namespace filesystem
 
     return mount_with_longest_prefix;
   }
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/open_file_description.cpp b/kernel/src/filesystem/open_file_description.cpp
index 93c38ac..8c04225 100644
--- a/kernel/src/filesystem/open_file_description.cpp
+++ b/kernel/src/filesystem/open_file_description.cpp
@@ -7,7 +7,7 @@
 
 #include <cstddef>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   open_file_description::open_file_description(kstd::shared_ptr<inode> const & inode)
       : m_inode(inode)
@@ -32,4 +32,4 @@ namespace filesystem
     m_offset += written_bytes;
     return written_bytes;
   }
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/filesystem/rootfs/filesystem.cpp b/kernel/src/filesystem/rootfs/filesystem.cpp
new file mode 100644
index 0000000..0133612
--- /dev/null
+++ b/kernel/src/filesystem/rootfs/filesystem.cpp
@@ -0,0 +1,29 @@
+#include "kernel/filesystem/rootfs/filesystem.hpp"
+
+#include "kernel/devices/device.hpp"
+#include "kernel/filesystem/inode.hpp"
+#include "kernel/filesystem/rootfs/inode.hpp"
+
+#include <kstd/memory>
+
+#include <string_view>
+
+namespace kernel::filesystem::rootfs
+{
+  auto filesystem::mount(kstd::shared_ptr<devices::device> const &) -> int
+  {
+    auto rfs_inode = kstd::make_shared<inode>();
+    rfs_inode->add_child("dev");
+    m_root_inode = rfs_inode;
+
+    return 0;
+  }
+
+  auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const & parent, std::string_view name)
+      -> kstd::shared_ptr<kernel::filesystem::inode>
+  {
+    if (auto * rfs_inode = static_cast<inode *>(parent.get()))
+      return rfs_inode->lookup_child(name);
+    return nullptr;
+  }
+}  // namespace kernel::filesystem::rootfs
diff --git a/kernel/src/filesystem/rootfs/inode.cpp b/kernel/src/filesystem/rootfs/inode.cpp
new file mode 100644
index 0000000..3ca9c02
--- /dev/null
+++ b/kernel/src/filesystem/rootfs/inode.cpp
@@ -0,0 +1,39 @@
+#include "kernel/filesystem/inode.hpp"
+
+#include "kernel/filesystem/rootfs/inode.hpp"
+
+#include <kstd/memory>
+#include <kstd/string>
+
+#include <algorithm>
+#include <cstddef>
+#include <string_view>
+#include <utility>
+
+namespace kernel::filesystem::rootfs
+{
+  inode::inode()
+      : kernel::filesystem::inode(inode_kind::directory)
+  {}
+
+  auto inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
+  {
+    return 0;
+  }
+
+  auto inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
+  {
+    return 0;
+  }
+
+  auto inode::add_child(std::string_view name) -> void
+  {
+    m_children.push_back(std::make_pair(kstd::string{name}, kstd::make_shared<inode>()));
+  }
+
+  auto inode::lookup_child(std::string_view name) -> kstd::shared_ptr<inode>
+  {
+    auto it = std::ranges::find_if(m_children, [&](auto const & pair) { return pair.first == name; });
+    return (it != m_children.end()) ? it->second : nullptr;
+  }
+}  // namespace kernel::filesystem::rootfs
diff --git a/kernel/src/filesystem/rootfs/rootfs_filesystem.cpp b/kernel/src/filesystem/rootfs/rootfs_filesystem.cpp
deleted file mode 100644
index 22502aa..0000000
--- a/kernel/src/filesystem/rootfs/rootfs_filesystem.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "kernel/filesystem/rootfs/rootfs_filesystem.hpp"
-
-#include "kernel/devices/device.hpp"
-#include "kernel/filesystem/inode.hpp"
-#include "kernel/filesystem/rootfs/rootfs_inode.hpp"
-
-#include <kstd/memory>
-
-#include <string_view>
-
-namespace filesystem::rootfs
-{
-  auto rootfs_filesystem::mount(kstd::shared_ptr<devices::device> const &) -> int
-  {
-    auto rfs_inode = kstd::make_shared<rootfs_inode>();
-    rfs_inode->add_child("dev");
-    m_root_inode = rfs_inode;
-
-    return 0;
-  }
-
-  auto rootfs_filesystem::lookup(kstd::shared_ptr<inode> const & parent, std::string_view name)
-      -> kstd::shared_ptr<inode>
-  {
-    if (auto * rfs_inode = static_cast<rootfs_inode *>(parent.get()))
-      return rfs_inode->lookup_child(name);
-    return nullptr;
-  }
-}  // namespace filesystem::rootfs
diff --git a/kernel/src/filesystem/rootfs/rootfs_inode.cpp b/kernel/src/filesystem/rootfs/rootfs_inode.cpp
deleted file mode 100644
index 9bbfbce..0000000
--- a/kernel/src/filesystem/rootfs/rootfs_inode.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "kernel/filesystem/rootfs/rootfs_inode.hpp"
-
-#include "kernel/filesystem/inode.hpp"
-
-#include <kstd/memory>
-#include <kstd/string>
-
-#include <algorithm>
-#include <cstddef>
-#include <string_view>
-#include <utility>
-
-namespace filesystem::rootfs
-{
-  rootfs_inode::rootfs_inode()
-      : inode(inode_kind::directory)
-  {}
-
-  auto rootfs_inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
-  {
-    return 0;
-  }
-
-  auto rootfs_inode::write(void const * /*buffer*/, size_t /*offset*/, size_t /*size*/) -> size_t
-  {
-    return 0;
-  }
-
-  auto rootfs_inode::add_child(std::string_view name) -> void
-  {
-    m_children.push_back(std::make_pair(kstd::string{name}, kstd::make_shared<rootfs_inode>()));
-  }
-
-  auto rootfs_inode::lookup_child(std::string_view name) -> kstd::shared_ptr<inode>
-  {
-    auto it = std::ranges::find_if(m_children, [&](auto const & pair) { return pair.first == name; });
-    return (it != m_children.end()) ? it->second : nullptr;
-  }
-}  // namespace filesystem::rootfs
diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
index 7a90531..06214d2 100644
--- a/kernel/src/filesystem/vfs.cpp
+++ b/kernel/src/filesystem/vfs.cpp
@@ -2,14 +2,14 @@
 
 #include "kapi/system.hpp"
 
-#include "kernel/devices/storage/storage_management.hpp"
+#include "kernel/devices/storage/management.hpp"
 #include "kernel/filesystem/dentry.hpp"
-#include "kernel/filesystem/devfs/devfs_filesystem.hpp"
-#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+#include "kernel/filesystem/devfs/filesystem.hpp"
+#include "kernel/filesystem/ext2/filesystem.hpp"
 #include "kernel/filesystem/filesystem.hpp"
 #include "kernel/filesystem/mount.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
-#include "kernel/filesystem/rootfs/rootfs_filesystem.hpp"
+#include "kernel/filesystem/rootfs/filesystem.hpp"
 
 #include <kstd/memory>
 
@@ -17,7 +17,7 @@
 #include <ranges>
 #include <string_view>
 
-namespace filesystem
+namespace kernel::filesystem
 {
   namespace
   {
@@ -37,22 +37,22 @@ namespace filesystem
 
   auto vfs::init_internal() -> void
   {
-    auto root_fs = kstd::make_shared<rootfs::rootfs_filesystem>();
+    auto root_fs = kstd::make_shared<rootfs::filesystem>();
     root_fs->mount(nullptr);
 
     auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode());
     m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, ""));
 
-    auto storage_mgmt = devices::storage::storage_management::get();
+    auto storage_mgmt = devices::storage::management::get();
     if (auto boot_device = storage_mgmt.determine_boot_device())
     {
       // TODO BA-FS26 detect fs type from boot device and load corresponding fs, for now just assume ext2
-      auto boot_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
+      auto boot_root_fs = kstd::make_shared<ext2::filesystem>();
       boot_root_fs->mount(boot_device);
       do_mount_internal("/", root_fs_root_dentry, boot_root_fs);
     }
 
-    auto device_fs = kstd::make_shared<devfs::devfs_filesystem>();
+    auto device_fs = kstd::make_shared<devfs::filesystem>();
     device_fs->mount(nullptr);
     do_mount_internal("/dev", root_fs_root_dentry, device_fs);
   }
@@ -161,4 +161,4 @@ namespace filesystem
     return current_dentry;
   }
 
-}  // namespace filesystem
\ No newline at end of file
+}  // namespace kernel::filesystem
\ No newline at end of file
diff --git a/kernel/src/main.cpp b/kernel/src/main.cpp
index bb6d57d..37b4c5b 100644
--- a/kernel/src/main.cpp
+++ b/kernel/src/main.cpp
@@ -5,9 +5,9 @@
 #include "kapi/memory.hpp"
 #include "kapi/system.hpp"
 
-#include "kernel/devices/storage/storage_management.hpp"
+#include "kernel/devices/storage/management.hpp"
 #include "kernel/filesystem/device_inode.hpp"
-#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+#include "kernel/filesystem/ext2/filesystem.hpp"
 #include "kernel/filesystem/file_descriptor_table.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
 #include "kernel/filesystem/vfs.hpp"
@@ -24,7 +24,7 @@
 
 auto test_device_names() -> void
 {
-  auto storage_mgmt = devices::storage::storage_management::get();
+  auto storage_mgmt = kernel::devices::storage::management::get();
   std::ranges::for_each(storage_mgmt.all_controllers(), [](auto const & controller) {
     std::ranges::for_each(controller->all_devices(),
                           [](auto const & device) { kstd::println("{}", device->name().view()); });
@@ -34,13 +34,13 @@ auto test_device_names() -> void
 auto test_file_description_manually() -> void
 {
   // setup
-  auto fd_table = filesystem::file_descriptor_table::get();
-  auto storage_mgmt = devices::storage::storage_management::get();
+  auto fd_table = kernel::filesystem::file_descriptor_table::get();
+  auto storage_mgmt = kernel::devices::storage::management::get();
   auto device = storage_mgmt.device_by_major_minor(1, 0);
 
-  auto dev_node = kstd::make_shared<filesystem::device_inode>(device);
+  auto dev_node = kstd::make_shared<kernel::filesystem::device_inode>(device);
 
-  auto ofd = kstd::make_shared<filesystem::open_file_description>(dev_node);
+  auto ofd = kstd::make_shared<kernel::filesystem::open_file_description>(dev_node);
   auto fd_index = fd_table.add_file(ofd);
 
   // use: read two bytes and write two again
@@ -66,7 +66,7 @@ auto test_file_description_manually() -> void
   fd_table.remove_file(fd_index);
 
   // use: read four bytes again -> two old bytes two new bytes
-  auto ofd1 = kstd::make_shared<filesystem::open_file_description>(dev_node);
+  auto ofd1 = kstd::make_shared<kernel::filesystem::open_file_description>(dev_node);
   fd_index = fd_table.add_file(ofd1);
   auto fd1 = fd_table.get_file(fd_index);
 
@@ -85,14 +85,14 @@ auto test_device_with_vfs() -> void
 {
   // TODO BA-FS26
 
-  auto vfs = filesystem::vfs::get();
+  auto vfs = kernel::filesystem::vfs::get();
   auto ofd = vfs.open("/dev/ram0");
   if (!ofd)
   {
     kstd::os::panic("test code failed");
   }
 
-  auto fd_table = filesystem::file_descriptor_table::get();
+  auto fd_table = kernel::filesystem::file_descriptor_table::get();
   auto fd = fd_table.add_file(ofd);
   kstd::vector<std::byte> buffer{2};
   auto file = fd_table.get_file(fd);
@@ -110,8 +110,8 @@ auto test_file_lookup() -> void
 {
   // TODO BA-FS26 implement a more complete test with multiple files and directories and mounts etc.
 
-  auto vfs = filesystem::vfs::get();
-  auto storage_mgmt = devices::storage::storage_management::get();
+  auto vfs = kernel::filesystem::vfs::get();
+  auto storage_mgmt = kernel::devices::storage::management::get();
 
   auto ofd1 = vfs.open("/a/b/c");
   auto ofd2 = vfs.open("/dev/ram0");
@@ -126,7 +126,7 @@ auto test_file_lookup() -> void
     kstd::os::panic("test code failed");
   }
 
-  auto new_filesystem = kstd::make_shared<filesystem::ext2::ext2_filesystem>();
+  auto new_filesystem = kstd::make_shared<kernel::filesystem::ext2::filesystem>();
   auto device = storage_mgmt.device_by_major_minor(1, 16);
   new_filesystem->mount(device);
   if (vfs.do_mount("/a/b", new_filesystem) != 0)
@@ -182,13 +182,13 @@ auto main() -> int
   kapi::boot_modules::init();
   kstd::println("[OS] Boot module registry initialized.");
 
-  devices::storage::storage_management::init();
+  kernel::devices::storage::management::init();
   kstd::println("[OS] Storage management initialized.");
 
-  filesystem::file_descriptor_table::init();
+  kernel::filesystem::file_descriptor_table::init();
   kstd::println("[OS] Global file descriptor table initialized.");
 
-  filesystem::vfs::init();
+  kernel::filesystem::vfs::init();
   kstd::println("[OS] Virtual filesystem initialized.");
 
   run_test_code();