17 files changed, 922 insertions, 5 deletions
diff --git a/kernel/src/devices/block_device.cpp b/kernel/src/devices/block_device.cpp
new file mode 100644
index 0000000..d12251b
--- /dev/null
+++ b/kernel/src/devices/block_device.cpp
@@ -0,0 +1,42 @@
+#include "kernel/devices/block_device.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/devices/device.hpp"
+
+#include <cstddef>
+#include <string_view>
+
+namespace devices
+{
+  block_device::block_device(size_t major, size_t minor, std::string_view name, size_t block_size)
+      : device(major, minor, name)
+      , m_block_size(block_size)
+  {
+    if (m_block_size == 0)
+    {
+      kapi::system::panic("[DEVICES] block_device constructed with zero block size.");
+    }
+  }
+
+  auto block_device::calculate_transfer(size_t block_index) const -> transfer_info
+  {
+    size_t const offset = block_index * m_block_size;
+    size_t const limit = size();
+
+    size_t const available = (offset < limit) ? (limit - offset) : 0;
+    size_t const to_transfer = (available < m_block_size) ? available : m_block_size;
+
+    return {offset, to_transfer, m_block_size - to_transfer};
+  }
+
+  auto block_device::block_size() const -> size_t
+  {
+    return m_block_size;
+  }
+
+  auto block_device::capacity() const -> size_t
+  {
+    return size();
+  }
+}  // namespace devices
+\ No newline at end of file
diff --git a/kernel/src/devices/device.cpp b/kernel/src/devices/device.cpp
new file mode 100644
index 0000000..29498fa
--- /dev/null
+++ b/kernel/src/devices/device.cpp
@@ -0,0 +1,28 @@
+#include "kernel/devices/device.hpp"
+
+#include <cstddef>
+#include <string_view>
+
+namespace devices
+{
+  device::device(size_t major, size_t minor, std::string_view name)
+      : m_major(major)
+      , m_minor(minor)
+      , m_name(name)
+  {}
+
+  auto device::major() const -> size_t
+  {
+    return m_major;
+  }
+
+  auto device::minor() const -> size_t
+  {
+    return m_minor;
+  }
+
+  auto device::name() const -> std::string_view
+  {
+    return m_name;
+  }
+}  // namespace devices
+\ 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
new file mode 100644
index 0000000..efb6256
--- /dev/null
+++ b/kernel/src/devices/storage/ram_disk/ram_disk_controller.cpp
@@ -0,0 +1,28 @@
+#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 <kstd/print>
+
+#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/ram_disk/ram_disk_device.cpp b/kernel/src/devices/storage/ram_disk/ram_disk_device.cpp
new file mode 100644
index 0000000..650a151
--- /dev/null
+++ b/kernel/src/devices/storage/ram_disk/ram_disk_device.cpp
@@ -0,0 +1,77 @@
+#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 <kstd/cstring>
+
+#include <array>
+#include <cstddef>
+#include <string_view>
+
+namespace devices::storage::ram_disk
+{
+  namespace
+  {
+    constexpr size_t RAM_DISK_BLOCK_SIZE = 512uz;
+
+    // TODO BA-FS26 @Felix
+    // TODO BA-FS26 currently only names for 9 minor devices
+    constinit std::array<char, 5> name = {'r', 'a', 'm', '0', '\0'};
+
+    auto determine_device_name(size_t minor) -> std::string_view
+    {
+      name[3] = '0' + minor;
+      return std::string_view{name};
+    }
+  }  // namespace
+
+  ram_disk_device::ram_disk_device(kapi::boot_modules::boot_module const & module, size_t major, size_t minor)
+      : block_device(major, minor, determine_device_name(minor), RAM_DISK_BLOCK_SIZE)
+      , m_boot_module(module)
+  {}
+
+  auto ram_disk_device::read_block(size_t block_index, void * buffer) const -> void
+  {
+    if (buffer == nullptr)
+    {
+      kapi::system::panic("[RAM DISK DEVICE] read_block called with null buffer.");
+    }
+
+    auto const info = calculate_transfer(block_index);
+
+    if (info.to_transfer > 0)
+    {
+      auto const src = static_cast<std::byte const *>(m_boot_module.start_address) + info.offset;
+      kstd::libc::memcpy(buffer, src, info.to_transfer);
+    }
+
+    if (info.remainder > 0)
+    {
+      kstd::libc::memset(static_cast<std::byte *>(buffer) + info.to_transfer, 0, info.remainder);
+    }
+  }
+
+  auto ram_disk_device::write_block(size_t block_index, void const * buffer) -> void
+  {
+    if (buffer == nullptr)
+    {
+      kapi::system::panic("[RAM DISK DEVICE] write_block called with null buffer.");
+    }
+
+    auto const info = calculate_transfer(block_index);
+
+    if (info.to_transfer > 0)
+    {
+      auto const dest = static_cast<std::byte *>(m_boot_module.start_address) + info.offset;
+      kstd::libc::memcpy(dest, buffer, info.to_transfer);
+    }
+  }
+
+  auto ram_disk_device::size() const -> size_t
+  {
+    return m_boot_module.size;
+  }
+}  // 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
new file mode 100644
index 0000000..e415436
--- /dev/null
+++ b/kernel/src/devices/storage/storage_controller.cpp
@@ -0,0 +1,44 @@
+#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/devices/storage/storage_management.cpp b/kernel/src/devices/storage/storage_management.cpp
new file mode 100644
index 0000000..56216b0
--- /dev/null
+++ b/kernel/src/devices/storage/storage_management.cpp
@@ -0,0 +1,85 @@
+#include "kernel/devices/storage/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 <kstd/memory>
+#include <kstd/vector>
+
+#include <algorithm>
+#include <cstddef>
+#include <optional>
+
+namespace devices::storage
+{
+  namespace
+  {
+    constexpr size_t static MINORS_PER_DEVICE = 16;
+    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>{};
+  }  // namespace
+
+  auto storage_management::init() -> void
+  {
+    if (active_storage_management)
+    {
+      kapi::system::panic("[DEVICES] Storage management has already been initialized.");
+    }
+    active_storage_management.emplace(storage_management{});
+
+    auto current_ram_disk_controller =
+        kstd::make_shared<ram_disk::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 &
+  {
+    if (!active_storage_management)
+    {
+      kapi::system::panic("[DEVICES] Storage management has not been initialized.");
+    }
+
+    return *active_storage_management;
+  }
+
+  auto storage_management::add_controller(kstd::shared_ptr<storage_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 &
+  {
+    return m_controllers;
+  }
+
+  auto storage_management::device_by_major_minor(size_t major, size_t minor) -> kstd::shared_ptr<device>
+  {
+    kstd::shared_ptr<device> found = nullptr;
+
+    std::ranges::find_if(m_controllers, [&](auto const & controller) {
+      if (controller != nullptr && controller->major() == major)
+      {
+        found = controller->device_by_minor(minor);
+        return found != nullptr;
+      }
+      return false;
+    });
+
+    return found;
+  }
+
+  auto storage_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
diff --git a/kernel/src/filesystem/custody.cpp b/kernel/src/filesystem/custody.cpp
new file mode 100644
index 0000000..a4dd12c
--- /dev/null
+++ b/kernel/src/filesystem/custody.cpp
@@ -0,0 +1,30 @@
+#include "kernel/filesystem/custody.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/filesystem/inode.hpp"
+
+#include <kstd/memory>
+
+namespace filesystem
+{
+  custody::custody(kstd::shared_ptr<custody> const & parent, kstd::shared_ptr<inode> const & node)
+      : m_parent(parent)
+      , m_inode(node)
+  {
+    if (!m_inode)
+    {
+      kapi::system::panic("[FILESYSTEM] custody constructed with null inode.");
+    }
+  }
+
+  auto custody::get_inode() const -> kstd::shared_ptr<inode> const &
+  {
+    return m_inode;
+  }
+
+  auto custody::get_parent() const -> kstd::shared_ptr<custody> const &
+  {
+    return m_parent;
+  }
+}  // namespace filesystem
+\ No newline at end of file
diff --git a/kernel/src/filesystem/device_file.cpp b/kernel/src/filesystem/device_file.cpp
new file mode 100644
index 0000000..c6db5af
--- /dev/null
+++ b/kernel/src/filesystem/device_file.cpp
@@ -0,0 +1,124 @@
+#include "kernel/filesystem/device_file.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/devices/block_device.hpp"
+#include "kernel/devices/device.hpp"
+
+#include <kstd/cstring>
+#include <kstd/memory>
+#include <kstd/vector>
+
+#include <algorithm>
+#include <cstddef>
+
+namespace filesystem
+{
+  device_file::device_file(kstd::shared_ptr<devices::device> const & device)
+      : m_device(device)
+  {
+    if (!m_device)
+    {
+      kapi::system::panic("[FILESYSTEM] device_file constructed with null device.");
+    }
+  }
+
+  auto device_file::open() -> void
+  {
+    // Hook point for permission checks or lazy metadata loading.
+  }
+
+  auto device_file::read(void * buffer, size_t offset, size_t size) const -> size_t
+  {
+    if (m_device->is_block_device())
+    {
+      return process_blocks(offset, size, buffer,
+                            [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
+                               std::byte * scratch, void * buffer) {
+                              auto * out = static_cast<std::byte *>(buffer);
+                              if (off == 0 && len == device->block_size())
+                              {
+                                device->read_block(idx, out + done);
+                              }
+                              else
+                              {
+                                device->read_block(idx, scratch);
+                                kstd::libc::memcpy(out + done, scratch + off, len);
+                              }
+                            });
+    }
+    else
+    {
+      kapi::system::panic("[FILESYSTEM] device_file::read called on non-block device.");
+    }
+  }
+
+  auto device_file::write(void const * buffer, size_t offset, size_t size) -> size_t
+  {
+    if (m_device->is_block_device())
+    {
+      return process_blocks(offset, size, const_cast<void *>(buffer),
+                            [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device,
+                               std::byte * scratch, void * buffer) {
+                              auto const * in = static_cast<std::byte const *>(buffer);
+                              if (off == 0 && len == device->block_size())
+                              {
+                                device->write_block(idx, in + done);
+                              }
+                              else
+                              {
+                                device->read_block(idx, scratch);
+                                kstd::libc::memcpy(scratch + off, in + done, len);
+                                device->write_block(idx, scratch);
+                              }
+                            });
+    }
+    else
+    {
+      kapi::system::panic("[FILESYSTEM] device_file::write called on non-block device.");
+    }
+  }
+
+  auto device_file::process_blocks(size_t offset, size_t size, void * buffer, block_op op) const -> size_t
+  {
+    if (buffer == nullptr)
+    {
+      kapi::system::panic("[FILESYSTEM] device_file::write called with null buffer.");
+    }
+
+    if (size == 0)
+    {
+      return 0;
+    }
+
+    auto * block_dev = static_cast<devices::block_device *>(m_device.get());
+    if (block_dev == nullptr)
+    {
+      kapi::system::panic("[FILESYSTEM] device_file: expected block_device.");
+    }
+
+    size_t const block_size = block_dev->block_size();
+    size_t const capacity = block_dev->capacity();
+
+    if (offset >= capacity)
+      return 0;
+    size_t const total_to_process = std::min(size, capacity - offset);
+
+    kstd::vector<std::byte> scratch_buffer{block_size};
+    auto processed = 0uz;
+
+    while (processed < total_to_process)
+    {
+      size_t const absolute_offset = offset + processed;
+      size_t const block_index = absolute_offset / block_size;
+      size_t const in_block_offset = absolute_offset % block_size;
+      size_t const chunk_size = std::min(total_to_process - processed, block_size - in_block_offset);
+
+      op(block_index, in_block_offset, chunk_size, processed, block_dev, scratch_buffer.data(), buffer);
+
+      processed += chunk_size;
+    }
+
+    return processed;
+  }
+}  // namespace filesystem
diff --git a/kernel/src/filesystem/ext2/ext2_filesystem.cpp b/kernel/src/filesystem/ext2/ext2_filesystem.cpp
new file mode 100644
index 0000000..408b292
--- /dev/null
+++ b/kernel/src/filesystem/ext2/ext2_filesystem.cpp
@@ -0,0 +1,33 @@
+#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+
+#include "kernel/devices/device.hpp"
+#include "kernel/filesystem/inode.hpp"
+#include "kernel/filesystem/inode_metadata.hpp"
+
+#include <kstd/memory>
+
+#include <string_view>
+
+namespace filesystem::ext2
+{
+  auto ext2_filesystem::mount(kstd::shared_ptr<devices::device> const & device) -> int
+  {
+    if (!device)
+    {
+      return -1;  // TODO BA-FS26 panic or errorcode?
+    }
+
+    m_device = device;
+    // TODO BA-FS26 load proper root inode from ext2 metadata
+    m_root_inode = inode{inode_kind::directory};
+
+    // TODO BA-FS26 implement
+    return 0;
+  }
+
+  auto ext2_filesystem::lookup(inode const & /*parent*/, std::string_view /*name*/) -> inode *
+  {
+    // TODO BA-FS26 implement ext2 directory traversal and inode loading
+    return nullptr;
+  }
+}  // namespace filesystem::ext2
diff --git a/kernel/src/filesystem/file_descriptor_table.cpp b/kernel/src/filesystem/file_descriptor_table.cpp
new file mode 100644
index 0000000..814322e
--- /dev/null
+++ b/kernel/src/filesystem/file_descriptor_table.cpp
@@ -0,0 +1,82 @@
+#include "kernel/filesystem/file_descriptor_table.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/filesystem/open_file_description.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <optional>
+
+namespace filesystem
+{
+  namespace
+  {
+    constinit auto static global_file_descriptor_table = std::optional<file_descriptor_table>{};
+  }  // namespace
+
+  auto file_descriptor_table::init() -> void
+  {
+    if (global_file_descriptor_table)
+    {
+      kapi::system::panic("[FILESYSTEM] File descriptor table has already been initialized.");
+    }
+
+    global_file_descriptor_table.emplace(file_descriptor_table{});
+  }
+
+  auto file_descriptor_table::get() -> file_descriptor_table &
+  {
+    if (!global_file_descriptor_table)
+    {
+      kapi::system::panic("[FILESYSTEM] File descriptor table has not been initialized.");
+    }
+
+    return *global_file_descriptor_table;
+  }
+
+  auto file_descriptor_table::add_file(open_file_description & file_description) -> int
+  {
+    auto it = std::ranges::find_if(m_open_files, [](auto & open_file) { return !open_file.has_value(); });
+    if (it != m_open_files.end())
+    {
+      *it = file_description;
+      return static_cast<int>(it - m_open_files.begin());
+    }
+
+    m_open_files.push_back(file_description);
+    return static_cast<int>(m_open_files.size() - 1);
+  }
+
+  auto file_descriptor_table::get_file(int fd) const -> std::optional<open_file_description>
+  {
+    if (fd < 0)
+    {
+      return std::nullopt;
+    }
+
+    auto const index = static_cast<size_t>(fd);
+    if (index >= m_open_files.size() || !m_open_files.at(fd).has_value())
+    {
+      return std::nullopt;
+    }
+
+    return m_open_files.at(fd);
+  }
+
+  auto file_descriptor_table::remove_file(int fd) -> void
+  {
+    if (fd < 0)
+    {
+      return;
+    }
+
+    auto const index = static_cast<size_t>(fd);
+    if (index >= m_open_files.size())
+    {
+      return;
+    }
+
+    m_open_files.at(fd).reset();
+  }
+}  // namespace filesystem
+\ No newline at end of file
diff --git a/kernel/src/filesystem/filesystem.cpp b/kernel/src/filesystem/filesystem.cpp
new file mode 100644
index 0000000..86b7940
--- /dev/null
+++ b/kernel/src/filesystem/filesystem.cpp
@@ -0,0 +1,11 @@
+#include "kernel/filesystem/filesystem.hpp"
+
+#include "kernel/filesystem/inode.hpp"
+
+namespace filesystem
+{
+  auto filesystem::root_inode() const -> inode const &
+  {
+    return m_root_inode;
+  }
+}  // namespace filesystem
+\ No newline at end of file
diff --git a/kernel/src/filesystem/inode.cpp b/kernel/src/filesystem/inode.cpp
new file mode 100644
index 0000000..af73662
--- /dev/null
+++ b/kernel/src/filesystem/inode.cpp
@@ -0,0 +1,108 @@
+#include "kernel/filesystem/inode.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/devices/device.hpp"
+#include "kernel/filesystem/inode_metadata.hpp"
+
+#include <kstd/memory>
+
+#include <cstddef>
+
+namespace filesystem
+{
+  inode::inode(inode_kind kind)
+      : m_kind(kind)
+  {}
+
+  inode::inode(kstd::shared_ptr<devices::device> const & device)
+      : m_kind(inode_kind::device)
+      , m_device(device)
+  {
+    if (!m_device)
+    {
+      kapi::system::panic("[FILESYSTEM] inode constructed with null device.");
+    }
+  }
+
+  auto inode::metadata() const -> inode_metadata
+  {
+    auto meta = inode_metadata{};
+    meta.kind = m_kind;
+
+    if (is_device())
+    {
+      meta.major = m_device->major();
+      meta.minor = m_device->minor();
+    }
+
+    return meta;
+  }
+
+  auto inode::is_directory() const -> bool
+  {
+    return m_kind == inode_kind::directory;
+  }
+
+  auto inode::is_regular() const -> bool
+  {
+    return m_kind == inode_kind::regular;
+  }
+
+  auto inode::is_device() const -> bool
+  {
+    return m_kind == inode_kind::device;
+  }
+
+  auto inode::is_block_device() const -> bool
+  {
+    return is_device() && m_device->is_block_device();
+  }
+
+  auto inode::major_device() const -> size_t
+  {
+    if (!is_device())
+    {
+      kapi::system::panic("[FILESYSTEM] inode::major_device called on non-device inode.");
+    }
+
+    return m_device->major();
+  }
+
+  auto inode::minor_device() const -> size_t
+  {
+    if (!is_device())
+    {
+      kapi::system::panic("[FILESYSTEM] inode::minor_device called on non-device inode.");
+    }
+
+    return m_device->minor();
+  }
+
+  auto inode::backing_device() const -> kstd::shared_ptr<devices::device> const &
+  {
+    return m_device;
+  }
+
+  auto inode::read(void * /*buffer*/, size_t /*offset*/, size_t /*size*/) const -> size_t
+  {
+    if (is_device())
+    {
+      kapi::system::panic("[FILESYSTEM] inode::read called on device inode. Open it as a device file first.");
+    }
+
+    // TODO BA-FS26
+    return 0;
+  }
+
+  auto inode::write(void const *, size_t, size_t) -> size_t
+  {
+    if (is_device())
+    {
+      kapi::system::panic("[FILESYSTEM] inode::write called on device inode. Open it as a device file first.");
+    }
+
+    kapi::system::panic("[FILESYSTEM] inode::write is not implemented yet");
+    return 0;
+  }
+}  // namespace filesystem
+\ No newline at end of file
diff --git a/kernel/src/filesystem/inode_file.cpp b/kernel/src/filesystem/inode_file.cpp
new file mode 100644
index 0000000..7abac7b
--- /dev/null
+++ b/kernel/src/filesystem/inode_file.cpp
@@ -0,0 +1,35 @@
+#include "kernel/filesystem/inode_file.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/filesystem/inode.hpp"
+
+#include <kstd/memory>
+
+#include <cstddef>
+
+namespace filesystem
+{
+  inode_file::inode_file(kstd::shared_ptr<inode> const & inode)
+      : m_inode(inode)
+  {
+    if (!m_inode)
+    {
+      kapi::system::panic("[FILESYSTEM] inode_file constructed with null inode");
+    }
+  }
+
+  auto inode_file::open() -> void
+  {
+    // Hook point for permission checks or lazy metadata loading.
+  }
+
+  auto inode_file::read(void * buffer, size_t offset, size_t size) const -> size_t
+  {
+    return m_inode->read(buffer, offset, size);
+  }
+  auto inode_file::write(void const * buffer, size_t offset, size_t size) -> size_t
+  {
+    return m_inode->write(buffer, offset, size);
+  }
+}  // namespace filesystem
+\ No newline at end of file
diff --git a/kernel/src/filesystem/mount.cpp b/kernel/src/filesystem/mount.cpp
new file mode 100644
index 0000000..a2c501f
--- /dev/null
+++ b/kernel/src/filesystem/mount.cpp
@@ -0,0 +1,32 @@
+#include "kernel/filesystem/mount.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/filesystem/filesystem.hpp"
+
+#include <kstd/memory>
+
+#include <string_view>
+
+namespace filesystem
+{
+  mount::mount(std::string_view const & path, kstd::shared_ptr<filesystem> const & fs)
+      : m_path(path)
+      , m_filesystem(fs)
+  {
+    if (!m_filesystem)
+    {
+      kapi::system::panic("[FILESYSTEM] mount initialized with null filesystem.");
+    }
+  }
+
+  auto mount::path() const -> std::string_view
+  {
+    return m_path;
+  }
+
+  auto mount::get_filesystem() const -> kstd::shared_ptr<filesystem> const &
+  {
+    return m_filesystem;
+  }
+}  // namespace 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
new file mode 100644
index 0000000..ff4d678
--- /dev/null
+++ b/kernel/src/filesystem/open_file_description.cpp
@@ -0,0 +1,35 @@
+#include "kernel/filesystem/open_file_description.hpp"
+
+#include "kernel/filesystem/file.hpp"
+
+#include <kstd/memory>
+#include <kstd/os/error.hpp>
+
+#include <cstddef>
+
+namespace filesystem
+{
+  open_file_description::open_file_description(kstd::shared_ptr<file> const & file)
+      : m_file(file)
+      , m_offset(0)
+  {
+    if (!file)
+    {
+      kstd::os::panic("[FILESYSTEM] open_file_description constructed with null file.");
+    }
+  }
+
+  auto open_file_description::read(void * buffer, size_t size) -> size_t
+  {
+    auto read_bytes = m_file->read(buffer, m_offset, size);
+    m_offset += read_bytes;
+    return read_bytes;
+  }
+
+  auto open_file_description::write(void const * buffer, size_t size) -> size_t
+  {
+    auto written_bytes = m_file->write(buffer, m_offset, size);
+    m_offset += written_bytes;
+    return written_bytes;
+  }
+}  // namespace filesystem
+\ No newline at end of file
diff --git a/kernel/src/filesystem/vfs.cpp b/kernel/src/filesystem/vfs.cpp
new file mode 100644
index 0000000..8d2ed0a
--- /dev/null
+++ b/kernel/src/filesystem/vfs.cpp
@@ -0,0 +1,123 @@
+#include "kernel/filesystem/vfs.hpp"
+
+#include "kapi/system.hpp"
+
+#include "kernel/devices/storage/storage_management.hpp"
+#include "kernel/filesystem/custody.hpp"
+#include "kernel/devices/device.hpp"
+#include "kernel/filesystem/device_file.hpp"
+#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
+#include "kernel/filesystem/inode.hpp"
+#include "kernel/filesystem/inode_file.hpp"
+#include "kernel/filesystem/mount.hpp"
+#include "kernel/filesystem/open_file_description.hpp"
+
+#include <kstd/cstring>
+#include <kstd/memory>
+
+#include <algorithm>
+#include <optional>
+#include <string_view>
+
+namespace filesystem
+{
+  namespace
+  {
+    constinit auto static active_vfs = std::optional<vfs>{};
+  }  // namespace
+
+  auto vfs::init() -> void
+  {
+    if (active_vfs)
+    {
+      kapi::system::panic("[FILESYSTEM] vfs has already been initialized.");
+    }
+
+    active_vfs.emplace(vfs{});
+
+    auto storage_mgmt = devices::storage::storage_management::get();
+    if (auto boot_device = storage_mgmt.determine_boot_device())
+    {
+      active_vfs->m_root_fs = kstd::make_shared<ext2::ext2_filesystem>();
+      if (active_vfs->m_root_fs->mount(boot_device) != 0)
+      {
+        kapi::system::panic("[FILESYSTEM] Failed to mount root filesystem.");
+      }
+
+      active_vfs->m_root_mount = mount{"/", active_vfs->m_root_fs};
+
+      std::ranges::for_each(storage_mgmt.all_controllers(), [&](auto controller) {
+        std::ranges::for_each(controller->all_devices(), [&](auto device) { active_vfs->make_device_node(device); });
+      });
+    }
+    else
+    {
+      // TODO BA-FS26 ?? what when no boot_device == no modules loaded??
+    }
+  }
+
+  auto vfs::get() -> vfs &
+  {
+    if (!active_vfs)
+    {
+      kapi::system::panic("[FILESYSTEM] vfs has not been initialized.");
+    }
+
+    return *active_vfs;
+  }
+
+  auto vfs::open(std::string_view path) -> std::optional<open_file_description>
+  {
+    if (auto custody = resolve_path(path))
+    {
+      auto node = custody->get_inode();
+      if (node->is_device())
+      {
+        auto current_device_file = kstd::make_shared<device_file>(node->backing_device());
+        current_device_file->open();
+        return open_file_description{current_device_file};
+      }
+
+      auto current_inode_file = kstd::make_shared<inode_file>(node);
+      current_inode_file->open();
+      return open_file_description{current_inode_file};
+    }
+
+    return std::nullopt;
+  }
+
+  auto vfs::make_device_node(kstd::shared_ptr<devices::device> const & device) -> void
+  {
+    if (!device)
+    {
+      kapi::system::panic("[FILESYSTEM] make_device_node called with null device.");
+    }
+
+    m_device_nodes.push_back(device_node_entry{device->name(), kstd::make_shared<inode>(device)});
+  }
+
+  auto vfs::resolve_path(std::string_view path) -> std::optional<custody>
+  {
+    // TODO BA-FS26 implement real path resolution with mounts and directories etc.
+    // For now, just support device nodes at /dev/<device_name>.
+
+    constexpr auto device_prefix = std::string_view{"/dev/"};
+    if (path.starts_with(device_prefix))
+    {
+      auto const device_name = path.substr(device_prefix.size());
+      auto entry = std::ranges::find_if(m_device_nodes, [&](auto const & device_entry) {
+        return device_entry.has_value() && device_entry->name == device_name;
+      });
+
+      if (entry != m_device_nodes.end())
+      {
+        return custody{nullptr, entry->value().node};
+      }
+
+      return std::nul