kernel: clean up error API

11 files changed, 76 insertions, 60 deletions

diff --git a/kernel/kernel/filesystem/devfs/filesystem.cpp b/kernel/kernel/filesystem/devfs/filesystem.cpp
index 226102ba..8af12131 100644
--- a/kernel/kernel/filesystem/devfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/devfs/filesystem.cpp
@@ -53,12 +53,12 @@ namespace kernel::filesystem::devfs
   {
     if (!parent || !parent->is_directory())
     {
-      return std::unexpected{make_error_code(kstd::errc::invalid_argument)};
+      return std::unexpected{vfs_errc::invalid_inode};
     }
 
     if (parent.get() != m_root_inode.get())
     {
-      return std::unexpected{make_error_code(kstd::errc::invalid_argument)};
+      return std::unexpected{vfs_errc::invalid_inode};
     }
 
     auto it = std::ranges::find_if(m_inodes, [&](auto const & dev_node) {
@@ -68,12 +68,13 @@ namespace kernel::filesystem::devfs
       }
       return false;
     });
+
     if (it != m_inodes.end())
     {
       return *it;
     }
 
-    return std::unexpected{make_error_code(vfs_errc::non_existent_path)};
+    return std::unexpected{vfs_errc::non_existent_path};
   }
 
   auto filesystem::build_device_inode_table() -> void
diff --git a/kernel/kernel/filesystem/error.hpp b/kernel/kernel/filesystem/error.hpp
index 267e5b7e..041b7b98 100644
--- a/kernel/kernel/filesystem/error.hpp
+++ b/kernel/kernel/filesystem/error.hpp
@@ -18,6 +18,10 @@ namespace kernel::filesystem
     has_child_mounts,
     invalid_filesystem,
     unmount_failed,
+    symbolic_link_loop,
+    unsupported_filesystem,
+    invalid_file_descriptor,
+    invalid_inode,
   };
 
   namespace detail
@@ -47,6 +51,14 @@ namespace kernel::filesystem
             return "invalid filesystem";
           case vfs_errc::unmount_failed:
             return "unmount failed";
+          case vfs_errc::symbolic_link_loop:
+            return "too many symbolic link levels";
+          case vfs_errc::unsupported_filesystem:
+            return "unsupported filesystem";
+          case vfs_errc::invalid_file_descriptor:
+            return "invalid file descriptor";
+          case vfs_errc::invalid_inode:
+            return "invalid inode";
           default:
             return "unknown VFS error";
         }
@@ -58,6 +70,7 @@ namespace kernel::filesystem
         {
           case vfs_errc::invalid_path:
           case vfs_errc::invalid_filesystem:
+          case vfs_errc::invalid_inode:
             return make_error_condition(kstd::errc::invalid_argument);
           case vfs_errc::non_existent_path:
           case vfs_errc::mount_point_not_found:
@@ -66,6 +79,12 @@ namespace kernel::filesystem
           case kernel::filesystem::vfs_errc::has_child_mounts:
           case vfs_errc::unmount_failed:
             return make_error_condition(kstd::errc::device_or_resource_busy);
+          case vfs_errc::symbolic_link_loop:
+            return make_error_condition(kstd::errc::too_many_symbolic_link_levels);
+          case vfs_errc::unsupported_filesystem:
+            return make_error_condition(kstd::errc::not_supported);
+          case vfs_errc::invalid_file_descriptor:
+            return make_error_condition(kstd::errc::bad_file_descriptor);
           default:
             return kstd::error_condition{value, *this};
         }
diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index fd77a0a2..55da8976 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -54,7 +54,7 @@ namespace kernel::filesystem::ext2
 
     if (m_superblock.magic != constants::magic_number)
     {
-      return std::unexpected{make_error_code(ext2_errc::invalid_magic_number)};
+      return std::unexpected{ext2_errc::invalid_magic_number};
     }
 
     auto const blocks_per_group = m_superblock.blocks_per_group;
@@ -72,7 +72,7 @@ namespace kernel::filesystem::ext2
 
     if (!m_root_inode || !m_root_inode->is_directory())
     {
-      return std::unexpected{make_error_code(ext2_errc::invalid_root_inode)};
+      return std::unexpected{ext2_errc::invalid_root_inode};
     }
 
     return {};
@@ -83,7 +83,7 @@ namespace kernel::filesystem::ext2
   {
     if (!parent || !parent->is_directory())
     {
-      return std::unexpected{make_error_code(kstd::errc::invalid_argument)};
+      return std::unexpected{vfs_errc::invalid_inode};
     }
 
     auto * ext2_parent = static_cast<inode *>(parent.get());
@@ -96,7 +96,7 @@ namespace kernel::filesystem::ext2
 
       if (!global_block_number)
       {
-        return std::unexpected{make_error_code(ext2_errc::invalid_block_number)};
+        return std::unexpected{ext2_errc::invalid_block_number};
       }
 
       auto const block_offset = global_block_number.value() * block_size();
@@ -118,7 +118,7 @@ namespace kernel::filesystem::ext2
       }
     }
 
-    return std::unexpected{make_error_code(vfs_errc::non_existent_path)};
+    return std::unexpected{vfs_errc::non_existent_path};
   }
 
   auto filesystem::read_inode(uint32_t inode_number) const -> std::expected<kstd::shared_ptr<inode>, kstd::error_code>
@@ -129,7 +129,7 @@ namespace kernel::filesystem::ext2
 
     if (block_group_index >= m_block_group_descriptors.size())
     {
-      return std::unexpected{make_error_code(ext2_errc::invalid_block_group_index)};
+      return std::unexpected{ext2_errc::invalid_block_group_index};
     }
 
     auto const & block_group_descriptor = m_block_group_descriptors.at(block_group_index);
@@ -196,7 +196,7 @@ namespace kernel::filesystem::ext2
       return block_number;
     }
 
-    return std::unexpected{make_error_code(ext2_errc::invalid_block_index)};
+    return std::unexpected{ext2_errc::invalid_block_index};
   }
 
   auto filesystem::read_block_number_at_index(uint32_t block_number, size_t index) const -> uint32_t
diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
index 9a677981..1702526e 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
@@ -82,8 +82,7 @@ SCENARIO("Ext2 filesystem rejects invalid magic", "[filesystem][ext2][filesystem
 
     THEN("mount fails with invalid_magic_number")
     {
-      REQUIRE(fs.mount(dev_inode).error() ==
-              make_error_code(kernel::filesystem::ext2::ext2_errc::invalid_magic_number));
+      REQUIRE(fs.mount(dev_inode).error() == kernel::filesystem::ext2::ext2_errc::invalid_magic_number);
     }
   }
 }
diff --git a/kernel/kernel/filesystem/filesystem.cpp b/kernel/kernel/filesystem/filesystem.cpp
index cb60734f..1d15d410 100644
--- a/kernel/kernel/filesystem/filesystem.cpp
+++ b/kernel/kernel/filesystem/filesystem.cpp
@@ -1,5 +1,6 @@
 #include <kernel/filesystem/filesystem.hpp>
 
+#include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/ext2/filesystem.hpp>
 #include <kernel/filesystem/inode.hpp>
 
@@ -37,7 +38,7 @@ namespace kernel::filesystem
       }
     }
 
-    return std::unexpected{make_error_code(kstd::errc::not_supported)};
+    return std::unexpected{vfs_errc::unsupported_filesystem};
   }
 
   auto filesystem::mount(kstd::shared_ptr<inode> const & backing_inode) -> std::expected<void, kstd::error_code>
diff --git a/kernel/kernel/filesystem/open_file_table.cpp b/kernel/kernel/filesystem/open_file_table.cpp
index df5717a4..1109249a 100644
--- a/kernel/kernel/filesystem/open_file_table.cpp
+++ b/kernel/kernel/filesystem/open_file_table.cpp
@@ -1,5 +1,6 @@
 #include <kernel/filesystem/open_file_table.hpp>
 
+#include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/open_file_descriptor.hpp>
 
 #include <kapi/system.hpp>
@@ -44,7 +45,7 @@ namespace kernel::filesystem
   {
     if (!file_descriptor)
     {
-      return std::unexpected{make_error_code(kstd::errc::invalid_argument)};
+      return std::unexpected{vfs_errc::invalid_file_descriptor};
     }
 
     auto it = std::ranges::find_if(m_open_files, [](auto const & open_file) { return open_file == nullptr; });
@@ -62,7 +63,7 @@ namespace kernel::filesystem
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
-      return std::unexpected{make_error_code(kstd::errc::invalid_argument)};
+      return std::unexpected{vfs_errc::invalid_file_descriptor};
     }
 
     return m_open_files.at(fd);
@@ -72,7 +73,7 @@ namespace kernel::filesystem
   {
     if (fd >= m_open_files.size() || m_open_files.at(fd) == nullptr)
     {
-      return std::unexpected{make_error_code(kstd::errc::invalid_argument)};
+      return std::unexpected{vfs_errc::invalid_file_descriptor};
     }
 
     m_open_files.at(fd) = nullptr;
diff --git a/kernel/kernel/filesystem/open_file_table.tests.cpp b/kernel/kernel/filesystem/open_file_table.tests.cpp
index 78afaa6d..69188528 100644
--- a/kernel/kernel/filesystem/open_file_table.tests.cpp
+++ b/kernel/kernel/filesystem/open_file_table.tests.cpp
@@ -50,13 +50,13 @@ SCENARIO("Open file table add/get file", "[filesystem][open_file_table]")
     THEN("adding a null file descriptor returns an error")
     {
       auto fd = table.add_file(nullptr);
-      REQUIRE(fd.error() == make_error_condition(kstd::errc::invalid_argument));
+      REQUIRE(fd.error() == kstd::errc::bad_file_descriptor);
     }
 
     THEN("retrieving a file descriptor with an out-of-bounds file descriptor returns an error")
     {
       auto retrieved_descriptor = table.file(1000);
-      REQUIRE(retrieved_descriptor.error() == make_error_condition(kstd::errc::invalid_argument));
+      REQUIRE(retrieved_descriptor.error() == kstd::errc::bad_file_descriptor);
     }
   }
 }
@@ -78,7 +78,7 @@ SCENARIO("Open file table remove file", "[filesystem][open_file_table]")
       THEN("the file descriptor can no longer be retrieved using the file descriptor")
       {
         auto retrieved_descriptor = table.file(*fd);
-        REQUIRE(retrieved_descriptor.error() == make_error_condition(kstd::errc::invalid_argument));
+        REQUIRE(retrieved_descriptor.error() == kstd::errc::bad_file_descriptor);
       }
     }
 
diff --git a/kernel/kernel/filesystem/rootfs/filesystem.cpp b/kernel/kernel/filesystem/rootfs/filesystem.cpp
index 06b6d5c9..4efacb6b 100644
--- a/kernel/kernel/filesystem/rootfs/filesystem.cpp
+++ b/kernel/kernel/filesystem/rootfs/filesystem.cpp
@@ -1,5 +1,6 @@
 #include <kernel/filesystem/rootfs/filesystem.hpp>
 
+#include <kernel/filesystem/error.hpp>
 #include <kernel/filesystem/filesystem.hpp>
 #include <kernel/filesystem/inode.hpp>
 #include <kernel/filesystem/rootfs/inode.hpp>
@@ -44,6 +45,6 @@ namespace kernel::filesystem::rootfs
   auto filesystem::lookup(kstd::shared_ptr<kernel::filesystem::inode> const &, std::string_view) const
       -> std::expected<kstd::shared_ptr<kernel::filesystem::inode>, kstd::error_code>
   {
-    return std::unexpected{make_error_code(kstd::errc::no_such_file_or_directory)};
+    return std::unexpected{vfs_errc::non_existent_path};
   }
 }  // namespace kernel::filesystem::rootfs
diff --git a/kernel/kernel/filesystem/vfs.cpp b/kernel/kernel/filesystem/vfs.cpp
index 45424ee2..5ffc3468 100644
--- a/kernel/kernel/filesystem/vfs.cpp
+++ b/kernel/kernel/filesystem/vfs.cpp
@@ -108,14 +108,14 @@ namespace kernel::filesystem
       mount.value()->decrement_ref_count();
       return {};
     }
-    return std::unexpected{make_error_code(vfs_errc::invalid_path)};
+    return std::unexpected{vfs_errc::invalid_path};
   }
 
   auto vfs::do_mount(std::string_view source, std::string_view target) -> std::expected<void, kstd::error_code>
   {
     if (!path::is_valid_path(source) || !path::is_valid_path(target))
     {
-      return std::unexpected{make_error_code(vfs_errc::invalid_path)};
+      return std::unexpected{vfs_errc::invalid_path};
     }
 
     auto resolved_target = resolve_path_internal(target);
@@ -146,7 +146,7 @@ namespace kernel::filesystem
   {
     if (!path::is_valid_path(path))
     {
-      return std::unexpected{make_error_code(vfs_errc::invalid_path)};
+      return std::unexpected{vfs_errc::invalid_path};
     }
 
     auto remove_result = m_mount_table.remove_mount(path);
@@ -156,10 +156,10 @@ namespace kernel::filesystem
     }
     else if (remove_result == mount_table::operation_result::mount_not_found)
     {
-      return std::unexpected{make_error_code(vfs_errc::mount_point_not_found)};
+      return std::unexpected{vfs_errc::mount_point_not_found};
     }
 
-    return std::unexpected{make_error_code(vfs_errc::unmount_failed)};
+    return std::unexpected{vfs_errc::unmount_failed};
   }
 
   auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
@@ -193,7 +193,7 @@ namespace kernel::filesystem
   {
     if (!path::is_valid_absolute_path(path))
     {
-      return std::unexpected{make_error_code(vfs_errc::invalid_path)};
+      return std::unexpected{vfs_errc::invalid_path};
     }
 
     auto current_mount = m_mount_table.find_mount("/");
@@ -270,7 +270,7 @@ namespace kernel::filesystem
       {
         if (symlink_counter++ > constants::symloop_max)
         {
-          return std::unexpected{make_error_code(kstd::errc::too_many_symbolic_link_levels)};
+          return std::unexpected{vfs_errc::symbolic_link_loop};
         }
 
         kstd::vector<uint8_t> buffer(constants::symlink_max_path_length);
diff --git a/kernel/kernel/filesystem/vfs.tests.cpp b/kernel/kernel/filesystem/vfs.tests.cpp
index e4f042e7..7ec70d9c 100644
--- a/kernel/kernel/filesystem/vfs.tests.cpp
+++ b/kernel/kernel/filesystem/vfs.tests.cpp
@@ -75,7 +75,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       auto & vfs = kernel::filesystem::vfs::get();
 
       auto image_1 = vfs.open("/dev/image_1.txt");
-      REQUIRE(image_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(image_1.error() == kstd::errc::no_such_file_or_directory);
 
       auto dev = vfs.open("/dev/ram0");
       REQUIRE(dev != nullptr);
@@ -112,7 +112,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
       REQUIRE(vfs.unmount("/information"));
       auto unmounted_monkey_1 = vfs.open("/information/monkey_house/monkey_1.txt");
-      REQUIRE(unmounted_monkey_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(unmounted_monkey_1.error() == kstd::errc::no_such_file_or_directory);
 
       auto info_1 = vfs.open("/information/info_1.txt");
       REQUIRE(info_1 != nullptr);
@@ -178,7 +178,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
       REQUIRE(vfs.unmount("/information"));
       mounted_tickets = vfs.open("/information/entrance/tickets.txt");
-      REQUIRE(mounted_tickets.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(mounted_tickets.error() == kstd::errc::no_such_file_or_directory);
 
       auto mounted_monkey = vfs.open("/information/monkey_house/monkey_1.txt");
       REQUIRE(mounted_monkey);
@@ -192,7 +192,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(vfs.do_mount("/dev/ram16", "/"));
 
       info_1 = vfs.open("/information/info_1.txt");
-      REQUIRE(info_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(info_1.error() == kstd::errc::no_such_file_or_directory);
 
       auto water = vfs.open("/monkey_house/infrastructure/water.txt");
       REQUIRE(water != nullptr);
@@ -213,7 +213,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(vfs.do_mount("/dev/ram16", "/"));
 
       info_1 = vfs.open("/information/info_1.txt");
-      REQUIRE(info_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(info_1.error() == kstd::errc::no_such_file_or_directory);
 
       auto water = vfs.open("/monkey_house/infrastructure/water.txt");
       REQUIRE(water != nullptr);
@@ -221,10 +221,9 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(vfs.close(water.value()->absolute_path()));
 
       auto dev_ram_16 = vfs.open("/dev/ram16");
-      REQUIRE(dev_ram_16.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(dev_ram_16.error() == kstd::errc::no_such_file_or_directory);
 
-      REQUIRE(vfs.do_mount("/dev/ram32", "/").error() ==
-              make_error_code(kernel::filesystem::vfs_errc::non_existent_path));
+      REQUIRE(vfs.do_mount("/dev/ram32", "/").error() == kstd::errc::no_such_file_or_directory);
 
       REQUIRE(vfs.unmount("/"));
 
@@ -243,7 +242,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(vfs.unmount("/"));
 
       info_1 = vfs.open("/information/info_1.txt");
-      REQUIRE(info_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(info_1.error() == kstd::errc::no_such_file_or_directory);
 
       REQUIRE(vfs.do_mount("/dev/ram0", "/"));
 
@@ -251,44 +250,39 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(info_1 != nullptr);
 
       auto dev_ram_0 = vfs.open("/dev/ram0");
-      REQUIRE(dev_ram_0.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(dev_ram_0.error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("mount with null file system fails")
     {
-      REQUIRE(vfs.do_mount("/closed.txt", "/information").error() == make_error_condition(kstd::errc::not_supported));
+      REQUIRE(vfs.do_mount("/closed.txt", "/information").error() == kstd::errc::not_supported);
     }
 
     THEN("mount with invalid path fails")
     {
-      REQUIRE(vfs.do_mount("/dev/ram16", "").error() == make_error_code(kernel::filesystem::vfs_errc::invalid_path));
-      REQUIRE(vfs.do_mount("/dev/ram16", "information").error() ==
-              make_error_code(kernel::filesystem::vfs_errc::invalid_path));
+      REQUIRE(vfs.do_mount("/dev/ram16", "").error() == kstd::errc::invalid_argument);
+      REQUIRE(vfs.do_mount("/dev/ram16", "information").error() == kstd::errc::invalid_argument);
     }
 
     THEN("mount with non-existent source path fails")
     {
-      REQUIRE(vfs.do_mount("/dev/nonexistent", "/information").error() ==
-              make_error_code(kernel::filesystem::vfs_errc::non_existent_path));
+      REQUIRE(vfs.do_mount("/dev/nonexistent", "/information").error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("mount with non-existent mount point fails")
     {
-      REQUIRE(vfs.do_mount("/dev/ram16", "/information/nonexistent").error() ==
-              make_error_code(kernel::filesystem::vfs_errc::non_existent_path));
+      REQUIRE(vfs.do_mount("/dev/ram16", "/information/nonexistent").error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("unmount with invalid path fails")
     {
-      REQUIRE(vfs.unmount("").error() == make_error_code(kernel::filesystem::vfs_errc::invalid_path));
-      REQUIRE(vfs.unmount("information").error() ==
-              make_error_code(kernel::filesystem::vfs_errc::mount_point_not_found));
+      REQUIRE(vfs.unmount("").error() == kstd::errc::invalid_argument);
+      REQUIRE(vfs.unmount("information").error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("unmounting non-existent mount point returns expected error code")
     {
-      REQUIRE(vfs.unmount("/information/nonexistent").error() ==
-              make_error_code(kernel::filesystem::vfs_errc::mount_point_not_found));
+      REQUIRE(vfs.unmount("/information/nonexistent").error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("a file can be access if . in the path")
@@ -348,7 +342,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(vfs.do_mount("/archiv/2024.img", "/information"));
 
       auto info_1 = vfs.open("/information/info_1.txt");
-      REQUIRE(info_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(info_1.error() == kstd::errc::no_such_file_or_directory);
 
       auto dentry = vfs.open("/information/sheep_1.txt");
       REQUIRE(dentry != nullptr);
@@ -363,7 +357,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
       REQUIRE(vfs.unmount("/information"));
       auto unmounted_sheep_1 = vfs.open("/information/sheep_1.txt");
-      REQUIRE(unmounted_sheep_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(unmounted_sheep_1.error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("the file-filesystem in the image can be mounted and in this filesystem can another file-filesystem be "
@@ -394,11 +388,11 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(vfs.close(sheep_1.value()->absolute_path()));
       REQUIRE(vfs.close(goat_1.value()->absolute_path()));
 
-      REQUIRE(vfs.unmount("/information").error() == make_error_code(kernel::filesystem::vfs_errc::unmount_failed));
+      REQUIRE(vfs.unmount("/information").error() == kstd::errc::device_or_resource_busy);
 
       REQUIRE(vfs.unmount("/information/stable"));
       auto unmounted_goat_1 = vfs.open("/information/stable/petting_zoo/goat_1.txt");
-      REQUIRE(unmounted_goat_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(unmounted_goat_1.error() == kstd::errc::no_such_file_or_directory);
 
       auto still_mounted_sheep_1 = vfs.open("/information/sheep_1.txt");
       REQUIRE(still_mounted_sheep_1 != nullptr);
@@ -407,7 +401,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
       REQUIRE(vfs.unmount("/information"));
       auto unmounted_sheep_1 = vfs.open("/information/sheep_1.txt");
-      REQUIRE(unmounted_sheep_1.error() == make_error_condition(kstd::errc::no_such_file_or_directory));
+      REQUIRE(unmounted_sheep_1.error() == kstd::errc::no_such_file_or_directory);
     }
   }
 
@@ -425,7 +419,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
       REQUIRE(vfs.do_mount("/dev/ram16", "/entrance"));
       REQUIRE(vfs.do_mount("/entrance/archiv/2024.img", "/enclosures"));
 
-      REQUIRE(vfs.unmount("/entrance").error() == make_error_code(kernel::filesystem::vfs_errc::unmount_failed));
+      REQUIRE(vfs.unmount("/entrance").error() == kstd::errc::device_or_resource_busy);
       REQUIRE(vfs.unmount("/enclosures"));
       REQUIRE(vfs.unmount("/entrance"));
     }
@@ -484,21 +478,21 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
     {
       auto & vfs = kernel::filesystem::vfs::get();
       auto invalid_symlink = vfs.open("/symlinks/invalid_absolute");
-      REQUIRE(invalid_symlink.error() == make_error_code(kernel::filesystem::vfs_errc::non_existent_path));
+      REQUIRE(invalid_symlink.error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("symbolic link containing an invalid relative path is handled correctly")
     {
       auto & vfs = kernel::filesystem::vfs::get();
       auto invalid_symlink = vfs.open("/symlinks/invalid_relative");
-      REQUIRE(invalid_symlink.error() == make_error_code(kernel::filesystem::vfs_errc::non_existent_path));
+      REQUIRE(invalid_symlink.error() == kstd::errc::no_such_file_or_directory);
     }
 
     THEN("circular symbolic links are detected and handled correctly")
     {
       auto & vfs = kernel::filesystem::vfs::get();
       auto circular_symlink = vfs.open("/symlinks/symloop_a");
-      REQUIRE(circular_symlink.error() == make_error_code(kstd::errc::too_many_symbolic_link_levels));
+      REQUIRE(circular_symlink.error() == kstd::errc::too_many_symbolic_link_levels);
     }
   }
 
diff --git a/kernel/kernel/main.cpp b/kernel/kernel/main.cpp
index 749040ce..28429b84 100644
--- a/kernel/kernel/main.cpp
+++ b/kernel/kernel/main.cpp
@@ -48,7 +48,7 @@ auto run_demo() -> void
   // 3) show that /entrance/information/info_1.txt is not accessible before mounting
   kstd::println("attempting to open /entrance/information/info_1.txt before mounting");
   auto fd_before_mount = kapi::filesystem::open("/entrance/information/info_1.txt");
-  if (!fd_before_mount && fd_before_mount.error() == make_error_condition(kstd::errc::no_such_file_or_directory))
+  if (!fd_before_mount && fd_before_mount.error() == kstd::errc::no_such_file_or_directory)
   {
     kstd::println("--> as expected the file could not be opened before mounting");
   }