Merge branch 'fmorgner/develop/kstd-system-error' into 'develop'

kstd: implement system_error infrastructure

See merge request teachos/kernel!54

11 files changed, 99 insertions, 118 deletions

diff --git a/kernel/kapi/acpi.cpp b/kernel/kapi/acpi.cpp
index b6d5cdf9..19188590 100644
--- a/kernel/kapi/acpi.cpp
+++ b/kernel/kapi/acpi.cpp
@@ -6,7 +6,7 @@
 
 #include <acpi/acpi.hpp>
 
-#include <kstd/memory>
+#include <kstd/memory.hpp>
 
 #include <atomic>
 #include <optional>
diff --git a/kernel/kapi/cpu.cpp b/kernel/kapi/cpu.cpp
index 7b1a43b3..44331908 100644
--- a/kernel/kapi/cpu.cpp
+++ b/kernel/kapi/cpu.cpp
@@ -2,7 +2,7 @@
 
 #include <kapi/system.hpp>
 
-#include <kstd/print>
+#include <kstd/print.hpp>
 
 namespace kapi::cpu
 {
diff --git a/kernel/kapi/devices.cpp b/kernel/kapi/devices.cpp
index 572227e6..577a8898 100644
--- a/kernel/kapi/devices.cpp
+++ b/kernel/kapi/devices.cpp
@@ -4,9 +4,9 @@
 
 #include <kapi/system.hpp>
 
-#include <kstd/flat_map>
-#include <kstd/memory>
-#include <kstd/print>
+#include <kstd/flat_map.hpp>
+#include <kstd/memory.hpp>
+#include <kstd/print.hpp>
 
 #include <atomic>
 #include <cstddef>
diff --git a/kernel/kapi/devices/bus.cpp b/kernel/kapi/devices/bus.cpp
index 59753f79..43310d2b 100644
--- a/kernel/kapi/devices/bus.cpp
+++ b/kernel/kapi/devices/bus.cpp
@@ -3,10 +3,10 @@
 #include <kapi/devices.hpp>
 #include <kapi/system.hpp>
 
-#include <kstd/memory>
-#include <kstd/print>
-#include <kstd/string>
-#include <kstd/vector>
+#include <kstd/memory.hpp>
+#include <kstd/print.hpp>
+#include <kstd/string.hpp>
+#include <kstd/vector.hpp>
 
 #include <algorithm>
 #include <cstddef>
diff --git a/kernel/kapi/devices/device.cpp b/kernel/kapi/devices/device.cpp
index 8b5d6b97..5dc59a27 100644
--- a/kernel/kapi/devices/device.cpp
+++ b/kernel/kapi/devices/device.cpp
@@ -2,8 +2,8 @@
 
 #include <kapi/devices/bus.hpp>
 
-#include <kstd/memory>
-#include <kstd/string>
+#include <kstd/memory.hpp>
+#include <kstd/string.hpp>
 
 #include <cstddef>
 
diff --git a/kernel/kapi/filesystem.cpp b/kernel/kapi/filesystem.cpp
index 68b51c97..efde1336 100644
--- a/kernel/kapi/filesystem.cpp
+++ b/kernel/kapi/filesystem.cpp
@@ -4,73 +4,53 @@
 #include <kernel/filesystem/open_file_table.hpp>
 #include <kernel/filesystem/vfs.hpp>
 
-#include <kstd/memory>
-#include <kstd/unikstd.h>
+#include <kstd/memory.hpp>
+#include <kstd/system_error.hpp>
 
 #include <cstddef>
+#include <expected>
 #include <string_view>
 
 namespace kapi::filesystem
 {
-  auto mount(std::string_view source, std::string_view target) -> kstd::ssize_t
+  auto mount(std::string_view source, std::string_view target) -> std::expected<void, kstd::error_code>
   {
-    if (kernel::filesystem::vfs::get().do_mount(source, target) == kernel::filesystem::vfs::operation_result::success)
-    {
-      return 0;
-    }
-    return -1;
+    return kernel::filesystem::vfs::get().mount(source, target);
   }
 
-  auto umount(std::string_view target) -> kstd::ssize_t
+  auto umount(std::string_view target) -> std::expected<void, kstd::error_code>
   {
-    if (kernel::filesystem::vfs::get().unmount(target) == kernel::filesystem::vfs::operation_result::success)
-    {
-      return 0;
-    }
-    return -1;
+    return kernel::filesystem::vfs::get().unmount(target);
   }
 
-  auto open(std::string_view path) -> kstd::ssize_t
+  auto open(std::string_view path) -> std::expected<std::size_t, kstd::error_code>
   {
-    if (auto dentry = kernel::filesystem::vfs::get().open(path))
-    {
+    return kernel::filesystem::vfs::get().open(path).and_then([](auto dentry) {
       auto open_file_descriptor = kstd::make_shared<kernel::filesystem::open_file_descriptor>(dentry);
       return kernel::filesystem::open_file_table::get().add_file(open_file_descriptor);
-    }
-
-    return -1;
+    });
   }
 
-  auto close(size_t file_descriptor) -> kstd::ssize_t
+  auto close(size_t file_descriptor) -> std::expected<void, kstd::error_code>
   {
-    if (auto open_file_descriptor = kernel::filesystem::open_file_table::get().file(file_descriptor))
-    {
-      if (kernel::filesystem::vfs::get().close(open_file_descriptor->get_dentry()->absolute_path()) ==
-          kernel::filesystem::vfs::operation_result::success)
-      {
-        return kernel::filesystem::open_file_table::get().remove_file(file_descriptor);
-      }
-    }
-    return -1;
+    return kernel::filesystem::open_file_table::get()
+        .file(file_descriptor)
+        .transform([](auto file) { return file->get_dentry()->absolute_path(); })
+        .and_then([](auto path) { return kernel::filesystem::vfs::get().close(path); })
+        .and_then([=]() { return kernel::filesystem::open_file_table::get().remove_file(file_descriptor); });
   }
 
-  auto read(size_t file_descriptor, void * buffer, size_t size) -> kstd::ssize_t
+  auto read(size_t file_descriptor, void * buffer, size_t size) -> std::expected<std::size_t, kstd::error_code>
   {
-    if (auto open_file_descriptor = kernel::filesystem::open_file_table::get().file(file_descriptor))
-    {
-      return open_file_descriptor->read(buffer, size);
-    }
-
-    return -1;
+    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) -> kstd::ssize_t
+  auto write(size_t file_descriptor, void const * buffer, size_t size) -> std::expected<std::size_t, kstd::error_code>
   {
-    if (auto open_file_descriptor = kernel::filesystem::open_file_table::get().file(file_descriptor))
-    {
-      return open_file_descriptor->write(buffer, size);
-    }
-
-    return -1;
+    return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
+      return descriptor->write(buffer, size);
+    });
   }
 }  // namespace kapi::filesystem
\ No newline at end of file
diff --git a/kernel/kapi/filesystem.tests.cpp b/kernel/kapi/filesystem.tests.cpp
index d241afa8..d1e01db6 100644
--- a/kernel/kapi/filesystem.tests.cpp
+++ b/kernel/kapi/filesystem.tests.cpp
@@ -2,6 +2,8 @@
 
 #include <kernel/test_support/filesystem/storage_boot_module_vfs_fixture.hpp>
 
+#include <kstd/system_error.hpp>
+
 #include <catch2/catch_test_macros.hpp>
 
 #include <algorithm>
@@ -25,159 +27,149 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Kap
 
     THEN("files can be opened, read and closed again")
     {
-      auto fd = kapi::filesystem::open("/information/info_1.txt");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/information/info_1.txt").value();
 
       auto buffer = std::vector<std::byte>(6);
       auto bytes_read = kapi::filesystem::read(fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_read >= 0);
+      REQUIRE(bytes_read);
 
-      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()), static_cast<size_t>(*bytes_read)};
       REQUIRE(buffer_as_str == "info_1");
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
+      REQUIRE(kapi::filesystem::close(fd));
     }
 
     THEN("files can be opened through absolute symbolic link, read and closed again")
     {
-      auto fd = kapi::filesystem::open("/symlinks/information_directory_absolute/info_1.txt");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/symlinks/information_directory_absolute/info_1.txt").value();
 
       auto buffer = std::vector<std::byte>(6);
       auto bytes_read = kapi::filesystem::read(fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_read >= 0);
+      REQUIRE(bytes_read);
 
-      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()), static_cast<size_t>(*bytes_read)};
       REQUIRE(buffer_as_str == "info_1");
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
+      REQUIRE(kapi::filesystem::close(fd));
     }
 
     THEN("files can be opened through relative symbolic link, read and closed again")
     {
-      auto fd = kapi::filesystem::open("/symlinks/information_directory_relative/info_1.txt");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/symlinks/information_directory_relative/info_1.txt").value();
 
       auto buffer = std::vector<std::byte>(6);
       auto bytes_read = kapi::filesystem::read(fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_read >= 0);
+      REQUIRE(bytes_read);
 
-      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()), static_cast<size_t>(*bytes_read)};
       REQUIRE(buffer_as_str == "info_1");
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
+      REQUIRE(kapi::filesystem::close(fd));
     }
 
     THEN("files can be opened through relative symbolic link over multiple mount points, read and closed again")
     {
-      kapi::filesystem::mount("/archiv/2024.img", "/information");
+      CHECK(kapi::filesystem::mount("/archiv/2024.img", "/information"));
 
-      auto fd = kapi::filesystem::open("/information/symlinks/traverse_back_twice/information/sheep_1.txt");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/information/symlinks/traverse_back_twice/information/sheep_1.txt").value();
 
       auto buffer = std::vector<std::byte>(7);
       auto bytes_read = kapi::filesystem::read(fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_read >= 0);
+      REQUIRE(bytes_read);
 
-      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()), static_cast<size_t>(*bytes_read)};
       REQUIRE(buffer_as_str == "sheep_1");
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
+      REQUIRE(kapi::filesystem::close(fd));
     }
 
     THEN("a filesystem can be mounted, files can be opened, read and closed again and unmounted")
     {
-      REQUIRE(kapi::filesystem::mount("/dev/ram16", "/information") == 0);
+      REQUIRE(kapi::filesystem::mount("/dev/ram16", "/information"));
 
-      auto fd = kapi::filesystem::open("/information/monkey_house/monkey_1.txt");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/information/monkey_house/monkey_1.txt").value();
 
       auto buffer = std::vector<std::byte>(8);
       auto bytes_read = kapi::filesystem::read(fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_read >= 0);
+      REQUIRE(bytes_read);
 
-      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()), static_cast<size_t>(*bytes_read)};
       REQUIRE(buffer_as_str == "monkey_1");
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
-      REQUIRE(kapi::filesystem::umount("/information") == 0);
+      REQUIRE(kapi::filesystem::close(fd));
+      REQUIRE(kapi::filesystem::umount("/information"));
     }
 
     THEN("a filesystem cannot be unmounted if files are still open and can be unmounted after files are closed")
     {
-      REQUIRE(kapi::filesystem::mount("/dev/ram16", "/information") == 0);
+      REQUIRE(kapi::filesystem::mount("/dev/ram16", "/information"));
 
-      auto fd = kapi::filesystem::open("/information/monkey_house/monkey_1.txt");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/information/monkey_house/monkey_1.txt").value();
 
-      REQUIRE(kapi::filesystem::umount("/information") < 0);
+      REQUIRE(!kapi::filesystem::umount("/information"));
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
-      REQUIRE(kapi::filesystem::umount("/information") == 0);
+      REQUIRE(kapi::filesystem::close(fd));
+      REQUIRE(kapi::filesystem::umount("/information"));
     }
 
     THEN("device can be opened as file and read from")
     {
-      auto fd = kapi::filesystem::open("/dev/ram0");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/dev/ram0").value();
 
       auto buffer = std::vector<std::byte>(512);
       auto bytes_read = kapi::filesystem::read(fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_read >= 0);
+      REQUIRE(bytes_read);
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
+      REQUIRE(kapi::filesystem::close(fd));
     }
 
     THEN("device can be opened as file and written to and read from again")
     {
-      auto read_fd = kapi::filesystem::open("/dev/ram16");
-      REQUIRE(read_fd >= 0);
+      auto read_fd = kapi::filesystem::open("/dev/ram16").value();
 
       auto buffer = std::vector<std::byte>(512, std::byte{0xAB});
       auto bytes_written = kapi::filesystem::write(read_fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_written >= 0);
+      REQUIRE(bytes_written);
 
-      auto write_fd = kapi::filesystem::open("/dev/ram16");
-      REQUIRE(write_fd >= 0);
+      auto write_fd = kapi::filesystem::open("/dev/ram16").value();
 
       auto read_buffer = std::vector<std::byte>(512);
       auto bytes_read = kapi::filesystem::read(write_fd, read_buffer.data(), read_buffer.size());
-      REQUIRE(bytes_read >= 0);
+      REQUIRE(bytes_read);
 
       REQUIRE(std::equal(buffer.begin(), buffer.end(), read_buffer.begin()));
 
-      REQUIRE(kapi::filesystem::close(write_fd) == 0);
-      REQUIRE(kapi::filesystem::close(read_fd) == 0);
+      REQUIRE(kapi::filesystem::close(write_fd));
+      REQUIRE(kapi::filesystem::close(read_fd));
     }
 
     THEN("invalid paths cannot be mounted or unmounted")
     {
-      REQUIRE(kapi::filesystem::mount("/dev/ram16", "invalid_path") < 0);
+      REQUIRE(!kapi::filesystem::mount("/dev/ram16", "invalid_path"));
     }
 
     THEN("invalid paths cannot be unmounted")
     {
-      REQUIRE(kapi::filesystem::umount("invalid_path") < 0);
+      REQUIRE(!kapi::filesystem::umount("invalid_path"));
     }
 
     THEN("non existent files cannot be opened")
     {
       auto fd = kapi::filesystem::open("/information/non_existent.txt");
-      REQUIRE(fd < 0);
+      REQUIRE(!fd);
     }
 
     THEN("not opened files cannot closed")
     {
-      REQUIRE(kapi::filesystem::close(999) < 0);
+      REQUIRE(!kapi::filesystem::close(999));
     }
 
     THEN("same file cannot be closed twice")
     {
-      auto fd = kapi::filesystem::open("/information/info_1.txt");
-      REQUIRE(fd >= 0);
+      auto fd = kapi::filesystem::open("/information/info_1.txt").value();
 
-      REQUIRE(kapi::filesystem::close(fd) == 0);
-      REQUIRE(kapi::filesystem::close(fd) < 0);
+      REQUIRE(kapi::filesystem::close(fd));
+      REQUIRE(!kapi::filesystem::close(fd));
     }
 
     THEN("not opened files cannot be read from")
@@ -185,7 +177,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Kap
       std::vector<std::byte> buffer(10);
       auto const invalid_fd = 999uz;
       auto bytes_read = kapi::filesystem::read(invalid_fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_read < 0);
+      REQUIRE(!bytes_read);
     }
 
     THEN("not opened files cannot be written to")
@@ -193,7 +185,7 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Kap
       std::vector<std::byte> buffer(10);
       auto const invalid_fd = 999uz;
       auto bytes_written = kapi::filesystem::write(invalid_fd, buffer.data(), buffer.size());
-      REQUIRE(bytes_written < 0);
+      REQUIRE(!bytes_written);
     }
   }
 }
diff --git a/kernel/kapi/interrupts.cpp b/kernel/kapi/interrupts.cpp
index 4efcaa37..18a1b29d 100644
--- a/kernel/kapi/interrupts.cpp
+++ b/kernel/kapi/interrupts.cpp
@@ -1,8 +1,8 @@
 #include <kapi/interrupts.hpp>
 
-#include <kstd/flat_map>
-#include <kstd/print>
-#include <kstd/vector>
+#include <kstd/flat_map.hpp>
+#include <kstd/print.hpp>
+#include <kstd/vector.hpp>
 
 #include <algorithm>
 #include <cstdint>
diff --git a/kernel/kapi/memory.cpp b/kernel/kapi/memory.cpp
index 5ea08b16..91a6c2c7 100644
--- a/kernel/kapi/memory.cpp
+++ b/kernel/kapi/memory.cpp
@@ -5,8 +5,8 @@
 
 #include <kapi/system.hpp>
 
-#include <kstd/print>
-#include <kstd/units>
+#include <kstd/print.hpp>
+#include <kstd/units.hpp>
 
 #include <algorithm>
 #include <cstddef>
diff --git a/kernel/kapi/system.cpp b/kernel/kapi/system.cpp
index 9819ceb7..629e5990 100644
--- a/kernel/kapi/system.cpp
+++ b/kernel/kapi/system.cpp
@@ -2,7 +2,8 @@
 
 #include <kapi/cpu.hpp>
 
-#include <kstd/print>
+#include <kstd/print.hpp>
+#include <kstd/system_error.hpp>
 
 #include <source_location>
 #include <string_view>
@@ -18,4 +19,12 @@ namespace kapi::system
     cpu::halt();
   }
 
+  [[gnu::weak]]
+  auto panic(std::string_view message, kstd::error_code error, std::source_location location) -> void
+  {
+    kstd::println(kstd::print_sink::stderr, "[PANIC] in {} : {} ({}) @ {}:{}", location.function_name(), message, error,
+                  location.file_name(), location.line());
+    cpu::halt();
+  }
+
 }  // namespace kapi::system
diff --git a/kernel/kapi/system.tests.cpp b/kernel/kapi/system.tests.cpp
index 1e300316..a05e348b 100644
--- a/kernel/kapi/system.tests.cpp
+++ b/kernel/kapi/system.tests.cpp
@@ -3,7 +3,7 @@
 #include <kernel/test_support/cio.hpp>
 #include <kernel/test_support/cpu.hpp>
 
-#include <kstd/print>
+#include <kstd/print.hpp>
 
 #include <catch2/catch_test_macros.hpp>