kernel/vfs: expand error_code integration

24 files changed, 145 insertions, 64 deletions

diff --git a/kernel/kapi/filesystem.cpp b/kernel/kapi/filesystem.cpp
index a7c8e403..efde1336 100644
--- a/kernel/kapi/filesystem.cpp
+++ b/kernel/kapi/filesystem.cpp
@@ -37,20 +37,19 @@ namespace kapi::filesystem
         .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); })
-        .transform([](auto) { return; });
+        .and_then([=]() { return kernel::filesystem::open_file_table::get().remove_file(file_descriptor); });
   }
 
   auto read(size_t file_descriptor, void * buffer, size_t size) -> std::expected<std::size_t, kstd::error_code>
   {
-    return kernel::filesystem::open_file_table::get().file(file_descriptor).transform([=](auto descriptor) {
+    return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->read(buffer, size);
     });
   }
 
   auto write(size_t file_descriptor, void const * buffer, size_t size) -> std::expected<std::size_t, kstd::error_code>
   {
-    return kernel::filesystem::open_file_table::get().file(file_descriptor).transform([=](auto descriptor) {
+    return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->write(buffer, size);
     });
   }
diff --git a/kernel/kernel/filesystem/devfs/inode.cpp b/kernel/kernel/filesystem/devfs/inode.cpp
index 7bbfbbed..2e4ee7de 100644
--- a/kernel/kernel/filesystem/devfs/inode.cpp
+++ b/kernel/kernel/filesystem/devfs/inode.cpp
@@ -1,15 +1,17 @@
 #include <kernel/filesystem/devfs/inode.hpp>
 
+#include <kstd/result.hpp>
+
 #include <cstddef>
 
 namespace kernel::filesystem::devfs
 {
-  auto inode::read(void *, size_t, size_t) const -> size_t
+  auto inode::read(void *, size_t, size_t) const -> kstd::result<size_t>
   {
     return 0;
   }
 
-  auto inode::write(void const *, size_t, size_t) -> size_t
+  auto inode::write(void const *, size_t, size_t) -> kstd::result<size_t>
   {
     return 0;
   }
diff --git a/kernel/kernel/filesystem/devfs/inode.hpp b/kernel/kernel/filesystem/devfs/inode.hpp
index e4288918..3472079f 100644
--- a/kernel/kernel/filesystem/devfs/inode.hpp
+++ b/kernel/kernel/filesystem/devfs/inode.hpp
@@ -3,6 +3,8 @@
 
 #include <kernel/filesystem/inode.hpp>
 
+#include <kstd/result.hpp>
+
 #include <cstddef>
 
 namespace kernel::filesystem::devfs
@@ -20,7 +22,7 @@ namespace kernel::filesystem::devfs
     @param size Number of bytes requested.
     @return Number of bytes read (always 0 because this inode does not expose file data).
     */
-    auto read(void * buffer, size_t offset, size_t size) const -> size_t override;
+    auto read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t> override;
 
     /**
     @brief Writes to the devfs directory inode.
@@ -29,7 +31,7 @@ namespace kernel::filesystem::devfs
     @param size Number of bytes requested.
     @return Number of bytes written (always 0 because writes are not supported for this inode).
     */
-    auto write(void const * buffer, size_t offset, size_t size) -> size_t override;
+    auto write(void const * buffer, size_t offset, size_t size) -> kstd::result<size_t> override;
 
     /**
     @brief Check if this inode represents a directory.
diff --git a/kernel/kernel/filesystem/device_inode.cpp b/kernel/kernel/filesystem/device_inode.cpp
index 091b5499..644e3df7 100644
--- a/kernel/kernel/filesystem/device_inode.cpp
+++ b/kernel/kernel/filesystem/device_inode.cpp
@@ -6,6 +6,7 @@
 #include <kapi/system.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 
 #include <cstddef>
 
@@ -20,7 +21,7 @@ namespace kernel::filesystem
     }
   }
 
-  auto device_inode::read(void * buffer, size_t offset, size_t size) const -> size_t
+  auto device_inode::read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t>
   {
     if (m_device->is_block_device())
     {
@@ -32,7 +33,7 @@ namespace kernel::filesystem
     }
   }
 
-  auto device_inode::write(void const * buffer, size_t offset, size_t size) -> size_t
+  auto device_inode::write(void const * buffer, size_t offset, size_t size) -> kstd::result<size_t>
   {
     if (m_device->is_block_device())
     {
diff --git a/kernel/kernel/filesystem/device_inode.hpp b/kernel/kernel/filesystem/device_inode.hpp
index b461f225..5b22366a 100644
--- a/kernel/kernel/filesystem/device_inode.hpp
+++ b/kernel/kernel/filesystem/device_inode.hpp
@@ -6,6 +6,7 @@
 #include <kapi/devices/device.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 
 #include <cstddef>
 
@@ -32,7 +33,7 @@ namespace kernel::filesystem
     @param size The number of bytes to read.
     @return The number of bytes read.
     */
-    auto read(void * buffer, size_t offset, size_t size) const -> size_t override;
+    auto read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t> override;
 
     /**
     @brief Write data to the device inode (and in the background from the associated device) from a @p buffer, starting
@@ -42,7 +43,7 @@ namespace kernel::filesystem
     @param size The number of bytes to write.
     @return The number of bytes written.
     */
-    auto write(void const * buffer, size_t offset, size_t size) -> size_t override;
+    auto write(void const * buffer, size_t offset, size_t size) -> kstd::result<size_t> override;
 
     /**
     @brief Get the associated device.
@@ -52,7 +53,7 @@ namespace kernel::filesystem
 
     /**
     @brief Check if this inode represents a device.
-    @return returns true, since this indoe is a device inode and represents a device.
+    @return returns true, since this inode is a device inode and represents a device.
     */
     [[nodiscard]] auto is_device() const -> bool override;
 
diff --git a/kernel/kernel/filesystem/ext2/error.hpp b/kernel/kernel/filesystem/ext2/error.hpp
index 885f82e6..79f40517 100644
--- a/kernel/kernel/filesystem/ext2/error.hpp
+++ b/kernel/kernel/filesystem/ext2/error.hpp
@@ -18,6 +18,8 @@ namespace kernel::filesystem::ext2
     invalid_block_group_index,
     invalid_block_index,
     invalid_block_number,
+    failed_to_read_superblock,
+    failed_to_read_block_group_descriptors,
   };
 
   namespace detail
@@ -43,6 +45,10 @@ namespace kernel::filesystem::ext2
             return "block index out of bounds";
           case ext2_errc::invalid_block_number:
             return "block number out of bounds";
+          case ext2_errc::failed_to_read_superblock:
+            return "failed to read superblock";
+          case ext2_errc::failed_to_read_block_group_descriptors:
+            return "failed to read block group descriptors";
           default:
             return "unknown ext2 error";
         };
@@ -67,6 +73,8 @@ namespace kernel::filesystem::ext2
           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:
             if (condition.category() == kstd::generic_category())
             {
               return condition.value() == static_cast<int>(kstd::errc::io_error);
diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index 4195ad05..34ee1f75 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -50,7 +50,11 @@ namespace kernel::filesystem::ext2
   {
     std::ignore = kernel::filesystem::filesystem::mount(backing_inode);
 
-    m_backing_inode->read(&m_superblock, constants::superblock_offset, sizeof(m_superblock));
+    if (auto read_result = m_backing_inode->read(&m_superblock, constants::superblock_offset, sizeof(m_superblock));
+        !read_result)
+    {
+      return kstd::failure(read_result.error());
+    }
 
     if (m_superblock.magic != constants::magic_number)
     {
@@ -62,8 +66,13 @@ namespace kernel::filesystem::ext2
 
     m_block_group_descriptors = kstd::vector<block_group_descriptor>(num_block_groups);
 
-    m_backing_inode->read(m_block_group_descriptors.data(), block_group_descriptor_table_offset(),
-                          num_block_groups * sizeof(block_group_descriptor));
+    if (auto read_result =
+            m_backing_inode->read(m_block_group_descriptors.data(), block_group_descriptor_table_offset(),
+                                  num_block_groups * sizeof(block_group_descriptor));
+        !read_result)
+    {
+      return kstd::failure(read_result.error());
+    }
 
     if (auto root_inode = read_inode(constants::root_inode_number))
     {
@@ -105,7 +114,10 @@ namespace kernel::filesystem::ext2
       }
 
       auto const block_offset = global_block_number.value() * block_size();
-      m_backing_inode->read(buffer.data(), block_offset, block_size());
+      if (auto read_result = m_backing_inode->read(buffer.data(), block_offset, block_size()); !read_result)
+      {
+        return kstd::failure(read_result.error());
+      }
 
       auto const * entry = reinterpret_cast<linked_directory_entry const *>(buffer.data());
       auto bytes_read = 0uz;
@@ -143,7 +155,10 @@ namespace kernel::filesystem::ext2
     auto const inode_offset = inode_table_offset + inode_index_within_group * inode_size();
 
     auto new_inode_data = inode_data{};
-    m_backing_inode->read(&new_inode_data, inode_offset, sizeof(inode_data));
+    if (auto read_result = m_backing_inode->read(&new_inode_data, inode_offset, sizeof(inode_data)); !read_result)
+    {
+      return kstd::failure(read_result.error());
+    }
 
     return kstd::make_shared<inode>(this, new_inode_data);
   }
@@ -186,7 +201,15 @@ namespace kernel::filesystem::ext2
         auto const idx = inode_block_index / stride;
         inode_block_index %= stride;
 
-        block_number = read_block_number_at_index(block_number, idx);
+        if (auto read_result = read_block_number_at_index(block_number, idx); !read_result)
+        {
+          return kstd::failure(read_result.error());
+        }
+        else
+        {
+          block_number = read_result.value();
+        }
+
         if (block_number == 0)
         {
           return 0;
@@ -204,13 +227,17 @@ namespace kernel::filesystem::ext2
     return kstd::failure(ext2_errc::invalid_block_index);
   }
 
-  auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t
+  auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> kstd::result<uint32_t>
   {
     uint32_t block_number_buffer = 0;
 
     auto const block_start_offset = block_number * block_size();
     auto const number_start_address = block_start_offset + index * sizeof(uint32_t);
-    m_backing_inode->read(&block_number_buffer, number_start_address, sizeof(uint32_t));
+    if (auto read_result = m_backing_inode->read(&block_number_buffer, number_start_address, sizeof(uint32_t));
+        !read_result)
+    {
+      return kstd::failure(read_result.error());
+    }
 
     return block_number_buffer;
   }
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index 58620596..5e5913bf 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -97,7 +97,7 @@ namespace kernel::filesystem::ext2
     [[nodiscard]] auto indirect_levels() const -> std::array<indirect_level, 3>;
 
     [[nodiscard]] auto read_inode(uint32_t inode_number) const -> kstd::result<kstd::shared_ptr<inode>>;
-    [[nodiscard]] auto read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t;
+    [[nodiscard]] auto read_block_number_at_index(uint32_t block_number, size_t index) const -> kstd::result<uint32_t>;
 
     [[nodiscard]] auto inode_size() const -> uint16_t;
     [[nodiscard]] auto inode_block_count(inode_data const & data) const -> uint32_t;
diff --git a/kernel/kernel/filesystem/ext2/inode.cpp b/kernel/kernel/filesystem/ext2/inode.cpp
index 23344a7b..6dadbec5 100644
--- a/kernel/kernel/filesystem/ext2/inode.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.cpp
@@ -6,6 +6,7 @@
 #include <kapi/system.hpp>
 
 #include <kstd/cstring.hpp>
+#include <kstd/result.hpp>
 
 #include <algorithm>
 #include <cstddef>
@@ -23,7 +24,7 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto inode::read(void * buffer, size_t offset, size_t size) const -> size_t
+  auto inode::read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t>
   {
     auto const max_readable = this->size() - offset;
     auto const requested_size = std::min(size, max_readable);
@@ -58,9 +59,14 @@ namespace kernel::filesystem::ext2
       {
         auto const block_start_offset = block_number.value() * m_filesystem->block_size();
         auto const read_offset = block_start_offset + in_block_offset;
-
-        bytes_read += m_filesystem->backing_inode()->read(static_cast<uint8_t *>(buffer) + bytes_read, read_offset,
-                                                          bytes_to_read);
+        auto const read_result = m_filesystem->backing_inode()->read(static_cast<uint8_t *>(buffer) + bytes_read,
+                                                                     read_offset, bytes_to_read);
+        if (!read_result)
+        {
+          return kstd::failure(read_result.error());
+        }
+
+        bytes_read += read_result.value();
       }
 
       block_index++;
@@ -70,7 +76,7 @@ namespace kernel::filesystem::ext2
     return bytes_read;
   }
 
-  auto inode::write(void const *, size_t, size_t) -> size_t
+  auto inode::write(void const *, size_t, size_t) -> kstd::result<size_t>
   {
     kapi::system::panic("[EXT2] inode::write is not implemented yet");
     return 0;
diff --git a/kernel/kernel/filesystem/ext2/inode.hpp b/kernel/kernel/filesystem/ext2/inode.hpp
index 8b63f787..16cb04e0 100644
--- a/kernel/kernel/filesystem/ext2/inode.hpp
+++ b/kernel/kernel/filesystem/ext2/inode.hpp
@@ -4,6 +4,7 @@
 #include <kernel/filesystem/inode.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 
 #include <array>
 #include <cstddef>
@@ -54,7 +55,7 @@ namespace kernel::filesystem::ext2
     @param size Number of bytes requested.
     @return Number of bytes read.
     */
-    auto read(void * buffer, size_t offset, size_t size) const -> size_t override;
+    auto read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t> override;
 
     /**
     @brief Writes to the ext2 inode into a @p buffer, starting at the specified @p offset and for a given @p size.
@@ -64,7 +65,7 @@ namespace kernel::filesystem::ext2
     @param size Number of bytes requested.
     @return Number of bytes written.
     */
-    auto write(void const * buffer, size_t offset, size_t size) -> size_t override;
+    auto write(void const * buffer, size_t offset, size_t size) -> kstd::result<size_t> override;
 
     /**
     @brief Get the data associated with this inode.
diff --git a/kernel/kernel/filesystem/ext2/inode.tests.cpp b/kernel/kernel/filesystem/ext2/inode.tests.cpp
index 325ba956..496e7c4f 100644
--- a/kernel/kernel/filesystem/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.tests.cpp
@@ -20,6 +20,8 @@
 #include <filesystem>
 #include <string_view>
 
+// NOLINTBEGIN(readability-magic-numbers)
+
 SCENARIO("Ext2 inode initialization and properties", "[filesystem][ext2][inode]")
 {
   GIVEN("an ext2 filesystem")
@@ -112,7 +114,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
 
       REQUIRE(bytes_read == 6);
 
-      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};
+      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), *bytes_read};
       REQUIRE(text == "info_1");
     }
 
@@ -159,7 +161,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
       auto const bytes_read = inode.read(buffer.data(), 0, buffer.size());
       REQUIRE(bytes_read == data.size);
 
-      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};
+      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), *bytes_read};
       REQUIRE(text.substr(0, 5) == "Hello");
       REQUIRE(std::ranges::all_of(text.substr(5, block_size - 5), [](char c) { return c == '\0'; }));
       REQUIRE(text.substr(2 * block_size, 6) == "World!");
@@ -200,7 +202,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
       auto const bytes_read = inode.read(buffer.data(), 0, buffer.size());
       REQUIRE(bytes_read == data.size);
 
-      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};
+      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), *bytes_read};
       REQUIRE(text.substr(0, 5) == "Hello");
       REQUIRE(std::ranges::all_of(text.substr(5, 12 * block_size - 5), [](char c) { return c == '\0'; }));
       REQUIRE(text.substr(12 * block_size, 4) == "Blub");
@@ -269,7 +271,7 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]")
       auto const bytes_read = inode.read(buffer.data(), block_size - 6, buffer.size());
       REQUIRE(bytes_read == 12);
 
-      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};
+      auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), *bytes_read};
       REQUIRE(text == "Hello World!");
     }
   }
@@ -373,4 +375,6 @@ SCENARIO("Ext2 inode get_size() correctly returns size depending on revision lev
       REQUIRE(inode.size() == 256);
     }
   }
-}
\ No newline at end of file
+}
+
+// NOLINTEND(readability-magic-numbers)
\ No newline at end of file
diff --git a/kernel/kernel/filesystem/inode.hpp b/kernel/kernel/filesystem/inode.hpp
index b34b921e..cfddebf6 100644
--- a/kernel/kernel/filesystem/inode.hpp
+++ b/kernel/kernel/filesystem/inode.hpp
@@ -1,6 +1,8 @@
 #ifndef TEACH_OS_KERNEL_FILESYSTEM_INODE_HPP
 #define TEACH_OS_KERNEL_FILESYSTEM_INODE_HPP
 
+#include <kstd/result.hpp>
+
 #include <cstddef>
 
 namespace kernel::filesystem
@@ -28,7 +30,7 @@ namespace kernel::filesystem
     @param size Number of bytes requested.
     @return Number of bytes read.
     */
-    virtual auto read(void * buffer, size_t offset, size_t size) const -> size_t = 0;
+    virtual auto read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t> = 0;
 
     /**
     @brief Writes to the inode into a @p buffer, starting at the specified @p offset and for a given @p size. This
@@ -38,7 +40,7 @@ namespace kernel::filesystem
     @param size Number of bytes to write.
     @return Number of bytes written.
     */
-    virtual auto write(void const * buffer, size_t offset, size_t size) -> size_t = 0;
+    virtual auto write(void const * buffer, size_t offset, size_t size) -> kstd::result<size_t> = 0;
 
     /**
     @brief Returns whether the inode is a directory.
diff --git a/kernel/kernel/filesystem/open_file_descriptor.cpp b/kernel/kernel/filesystem/open_file_descriptor.cpp
index bec484d7..ecf3e725 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.cpp
+++ b/kernel/kernel/filesystem/open_file_descriptor.cpp
@@ -4,6 +4,7 @@
 
 #include <kstd/memory.hpp>
 #include <kstd/os/error.hpp>
+#include <kstd/result.hpp>
 
 #include <cstddef>
 
@@ -19,18 +20,32 @@ namespace kernel::filesystem
     }
   }
 
-  auto open_file_descriptor::read(void * buffer, size_t size) -> size_t
+  auto open_file_descriptor::read(void * buffer, size_t size) -> kstd::result<size_t>
   {
-    auto read_bytes = m_dentry->get_inode()->read(buffer, m_offset, size);
-    m_offset += read_bytes;
-    return read_bytes;
+    if (auto result = m_dentry->get_inode()->read(buffer, m_offset, size); !result)
+    {
+      return kstd::failure(result.error());
+    }
+    else
+    {
+      auto read_bytes = result.value();
+      m_offset += read_bytes;
+      return read_bytes;
+    }
   }
 
-  auto open_file_descriptor::write(void const * buffer, size_t size) -> size_t
+  auto open_file_descriptor::write(void const * buffer, size_t size) -> kstd::result<size_t>
   {
-    auto written_bytes = m_dentry->get_inode()->write(buffer, m_offset, size);
-    m_offset += written_bytes;
-    return written_bytes;
+    if (auto result = m_dentry->get_inode()->write(buffer, m_offset, size); !result)
+    {
+      return kstd::failure(result.error());
+    }
+    else
+    {
+      auto written_bytes = result.value();
+      m_offset += written_bytes;
+      return written_bytes;
+    }
   }
 
   auto open_file_descriptor::offset() const -> size_t
diff --git a/kernel/kernel/filesystem/open_file_descriptor.hpp b/kernel/kernel/filesystem/open_file_descriptor.hpp
index beb32ec6..f6899a31 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.hpp
+++ b/kernel/kernel/filesystem/open_file_descriptor.hpp
@@ -4,6 +4,7 @@
 #include <kernel/filesystem/dentry.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 
 #include <cstddef>
 
@@ -34,7 +35,7 @@ namespace kernel::filesystem
     @param size The number of bytes to read.
     @return The number of bytes read.
     */
-    auto read(void * buffer, size_t size) -> size_t;
+    auto read(void * buffer, size_t size) -> kstd::result<size_t>;
 
     /**
     @brief Writes data to the open file descriptor from a @p buffer, starting at the current file offset and for a
@@ -44,7 +45,7 @@ namespace kernel::filesystem
     @param size The number of bytes to write.
     @return The number of bytes written.
     */
-    auto write(void const * buffer, size_t size) -> size_t;
+    auto write(void const * buffer, size_t size) -> kstd::result<size_t>;
 
     /**
     @brief Returns the current file offset for this open file descriptor.
diff --git a/kernel/kernel/filesystem/open_file_descriptor.tests.cpp b/kernel/kernel/filesystem/open_file_descriptor.tests.cpp
index a04fbaa5..06488ba0 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.tests.cpp
+++ b/kernel/kernel/filesystem/open_file_descriptor.tests.cpp
@@ -91,7 +91,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Ope
       REQUIRE(bytes_read == 7);
       REQUIRE(ofd->offset() == 7);
 
-      std::string_view buffer_as_str{reinterpret_cast<char *>(buffer.data()), static_cast<size_t>(bytes_read)};
+      std::string_view buffer_as_str{reinterpret_cast<char *>(buffer.data()), *bytes_read};
       REQUIRE(buffer_as_str == "info_1\n");
     }
 
@@ -106,7 +106,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Ope
       REQUIRE(bytes_read_2 == buffer.size() / 2);
       REQUIRE(ofd->offset() == buffer.size());
 
-      std::string_view buffer_as_str{reinterpret_cast<char *>(buffer.data()), bytes_read_1 + bytes_read_2};
+      std::string_view buffer_as_str{reinterpret_cast<char *>(buffer.data()), *bytes_read_1 + *bytes_read_2};
       REQUIRE(buffer_as_str == "info");
     }
   }
diff --git a/kernel/kernel/filesystem/open_file_table.cpp b/kernel/kernel/filesystem/open_file_table.cpp
index f33fed2e..dea504e4 100644
--- a/kernel/kernel/filesystem/open_file_table.cpp
+++ b/kernel/kernel/filesystem/open_file_table.cpp
@@ -69,7 +69,7 @@ namespace kernel::filesystem
     return kstd::success(m_open_files.at(fd));
   }
 
-  auto open_file_table::remove_file(size_t fd) -> kstd::result<std::size_t>
+  auto open_file_table::remove_file(size_t fd) -> kstd::result<void>
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
@@ -77,7 +77,7 @@ namespace kernel::filesystem
     }
 
     m_open_files.at(fd) = nullptr;
-    return kstd::success(0);
+    return kstd::success();
   }
 }  // namespace kernel::filesystem
 
diff --git a/kernel/kernel/filesystem/open_file_table.hpp b/kernel/kernel/filesystem/open_file_table.hpp
index a2c0e028..7c9a0c0c 100644
--- a/kernel/kernel/filesystem/open_file_table.hpp
+++ b/kernel/kernel/filesystem/open_file_table.hpp
@@ -55,7 +55,7 @@ namespace kernel::filesystem
     @param fd The file descriptor index to remove.
     @return 0 on success, or -1 on failure.
     */
-    auto remove_file(size_t fd) -> kstd::result<std::size_t>;
+    auto remove_file(size_t fd) -> kstd::result<void>;
 
   private:
     open_file_table() = default;
diff --git a/kernel/kernel/filesystem/rootfs/inode.cpp b/kernel/kernel/filesystem/rootfs/inode.cpp
index f64fb87c..e3e9d641 100644
--- a/kernel/kernel/filesystem/rootfs/inode.cpp
+++ b/kernel/kernel/filesystem/rootfs/inode.cpp
@@ -2,16 +2,18 @@
 
 #include <kernel/filesystem/rootfs/inode.hpp>
 
+#include <kstd/result.hpp>
+
 #include <cstddef>
 
 namespace kernel::filesystem::rootfs
 {
-  auto inode::read(void *, size_t, size_t) const -> size_t
+  auto inode::read(void *, size_t, size_t) const -> kstd::result<size_t>
   {
     return 0;
   }
 
-  auto inode::write(void const *, size_t, size_t) -> size_t
+  auto inode::write(void const *, size_t, size_t) -> kstd::result<size_t>
   {
     return 0;
   }
diff --git a/kernel/kernel/filesystem/rootfs/inode.hpp b/kernel/kernel/filesystem/rootfs/inode.hpp
index ee5b9012..777f13f9 100644
--- a/kernel/kernel/filesystem/rootfs/inode.hpp
+++ b/kernel/kernel/filesystem/rootfs/inode.hpp
@@ -4,6 +4,7 @@
 #include <kernel/filesystem/inode.hpp>
 
 #include <kstd/memory.hpp>
+#include <kstd/result.hpp>
 #include <kstd/string.hpp>
 #include <kstd/vector.hpp>
 
@@ -23,7 +24,7 @@ namespace kernel::filesystem::rootfs
     @param size Number of bytes requested.
     @return Number of bytes read (always 0 because this inode does not expose file data).
     */
-    auto read(void * buffer, size_t offset, size_t size) const -> size_t override;
+    auto read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t> override;
 
     /**
     @brief Writes to the rootfs directory inode.
@@ -32,7 +33,7 @@ namespace kernel::filesystem::rootfs
     @param size Number of bytes requested.
     @return Number of bytes written (always 0 because writes are not supported for this inode).
     */
-    auto write(void const * buffer, size_t offset, size_t size) -> size_t override;
+    auto write(void const * buffer, size_t offset, size_t size) -> kstd::result<size_t> override;
 
     /**
     @brief Check if this inode represents a directory.
diff --git a/kernel/kernel/filesystem/vfs.cpp b/kernel/kernel/filesystem/vfs.cpp
index 9aa8b2df..d128bbf5 100644
--- a/kernel/kernel/filesystem/vfs.cpp
+++ b/kernel/kernel/filesystem/vfs.cpp
@@ -287,7 +287,12 @@ namespace kernel::filesystem
 
         kstd::vector<uint8_t> buffer(constants::symlink_max_path_length);
         auto const bytes_read = next_dentry->get_inode()->read(buffer.data(), 0, buffer.size());
-        auto const symbolic_link_path = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};
+        if (!bytes_read)
+        {
+          return kstd::failure(bytes_read.error());
+        }
+
+        auto const symbolic_link_path = std::string_view{reinterpret_cast<char const *>(buffer.data()), *bytes_read};
 
         auto symbolic_link_parts = path::split(symbolic_link_path);
         kstd::vector symbolic_link_parts_vector(symbolic_link_parts.begin(), symbolic_link_parts.end());
diff --git a/kernel/kernel/filesystem/vfs.tests.cpp b/kernel/kernel/filesystem/vfs.tests.cpp
index 8ef24a15..c99cea90 100644
--- a/kernel/kernel/filesystem/vfs.tests.cpp
+++ b/kernel/kernel/filesystem/vfs.tests.cpp
@@ -350,7 +350,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
       kstd::vector<std::byte> buffer(7);
       auto bytes_read = sheep_1_ofd->read(buffer.data(), buffer.size());
-      std::string_view buffer_as_str{reinterpret_cast<char *>(buffer.data()), bytes_read};
+      std::string_view buffer_as_str{reinterpret_cast<char *>(buffer.data()), *bytes_read};
       REQUIRE(buffer_as_str == "sheep_1");
 
       REQUIRE(vfs.close(dentry.value()->absolute_path()));
@@ -377,12 +377,12 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
       kstd::vector<std::byte> sheep_buffer(7);
       auto bytes_read = sheep_1_ofd->read(sheep_buffer.data(), sheep_buffer.size());
-      std::string_view buffer_as_str{reinterpret_cast<char *>(sheep_buffer.data()), bytes_read};
+      std::string_view buffer_as_str{reinterpret_cast<char *>(sheep_buffer.data()), *bytes_read};
       REQUIRE(buffer_as_str == "sheep_1");
 
       kstd::vector<std::byte> goat_buffer(6);
       bytes_read = goat_1_ofd->read(goat_buffer.data(), goat_buffer.size());
-      buffer_as_str = std::string_view{reinterpret_cast<char *>(goat_buffer.data()), bytes_read};
+      buffer_as_str = std::string_view{reinterpret_cast<char *>(goat_buffer.data()), *bytes_read};
       REQUIRE(buffer_as_str == "goat_1");
 
       REQUIRE(vfs.close(sheep_1.value()->absolute_path()));
diff --git a/kernel/kernel/main.cpp b/kernel/kernel/main.cpp
index 28429b84..8dce5143 100644
--- a/kernel/kernel/main.cpp
+++ b/kernel/kernel/main.cpp
@@ -147,7 +147,7 @@ auto main() -> int
   kstd::println("[OS] Virtual filesystem initialized.");
 
   // TODO BA-FS26 remove demo code?
-  // run_demo();
+  run_demo();
 
   kapi::system::panic("Returning from kernel main!");
 }
diff --git a/kernel/kernel/test_support/filesystem/inode.cpp b/kernel/kernel/test_support/filesystem/inode.cpp
index 0c8d9563..fd8e4d69 100644
--- a/kernel/kernel/test_support/filesystem/inode.cpp
+++ b/kernel/kernel/test_support/filesystem/inode.cpp
@@ -2,16 +2,18 @@
 
 #include <kernel/filesystem/inode.hpp>
 
+#include <kstd/result.hpp>
+
 #include <cstddef>
 
 namespace kernel::tests::filesystem
 {
-  auto inode::read(void *, size_t, size_t size) const -> size_t
+  auto inode::read(void *, size_t, size_t size) const -> kstd::result<size_t>
   {
     return size;
   }
 
-  auto inode::write(void const *, size_t, size_t size) -> size_t
+  auto inode::write(void const *, size_t, size_t size) -> kstd::result<size_t>
   {
     return size;
   }
diff --git a/kernel/kernel/test_support/filesystem/inode.hpp b/kernel/kernel/test_support/filesystem/inode.hpp
index 8a764375..da2e3e21 100644
--- a/kernel/kernel/test_support/filesystem/inode.hpp
+++ b/kernel/kernel/test_support/filesystem/inode.hpp
@@ -3,14 +3,16 @@
 
 #include <kernel/filesystem/inode.hpp>
 
+#include <kstd/result.hpp>
+
 #include <cstddef>
 
 namespace kernel::tests::filesystem
 {
   struct inode : kernel::filesystem::inode
   {
-    auto read(void * buffer, size_t offset, size_t size) const -> size_t override;
-    auto write(void const * buffer, size_t offset, size_t size) -> size_t override;
+    auto read(void * buffer, size_t offset, size_t size) const -> kstd::result<size_t> override;
+    auto write(void const * buffer, size_t offset, size_t size) -> kstd::result<size_t> override;
 
     [[nodiscard]] auto is_regular() const -> bool override;
   };