chore: fix message prefixes

2 files changed, 43 insertions, 45 deletions

diff --git a/kernel/kapi/tracked_mutex.cpp b/kernel/kapi/tracked_mutex.cpp
index b1796adc..1694d814 100644
--- a/kernel/kapi/tracked_mutex.cpp
+++ b/kernel/kapi/tracked_mutex.cpp
@@ -17,7 +17,7 @@ namespace kapi
     {
       if (expected == self)
       {
-        system::panic("[OS] CPU {} tried to reacquire a mutex it already holds!", self);
+        system::panic("[OS:LCK] CPU {} tried to reacquire a mutex it already holds!", self);
       }
       expected = kapi::cpu::invalid_id;
     }
@@ -43,7 +43,7 @@ namespace kapi
 
     if (!m_owner.compare_exchange_strong(expected, kapi::cpu::invalid_id, std::memory_order::release))
     {
-      system::panic("[OS] CPU {} released a mutex it did not hold!", self);
+      system::panic("[OS:LCK] CPU {} released a mutex it did not hold!", self);
     }
   }
 
diff --git a/kernel/kernel/main.cpp b/kernel/kernel/main.cpp
index ac2e18b8..bc192950 100644
--- a/kernel/kernel/main.cpp
+++ b/kernel/kernel/main.cpp
@@ -28,84 +28,82 @@ using namespace kstd::units_literals;
 auto run_demo() -> void
 {
   // 1) open a file
-  kstd::println("attempting to open /entrance/tickets.txt");
+  kstd::println("trying to open /entrance/tickets.txt");
   auto fd_1 = kapi::filesystem::open("/entrance/tickets.txt");
   if (!fd_1)
   {
-    kapi::system::panic("[demo failed]");
+    kapi::system::panic("[OS:DEM] failed to open '/entrance/tickets.txt'", fd_1.error());
   }
   else
   {
-    kstd::println("--> successfully opened /entrance/tickets.txt with file descriptor {}", fd_1.value());
+    kstd::println("[OS:DEM] opened /entrance/tickets.txt with file descriptor {}", fd_1.value());
   }
 
   // 2) read from the file
   kstd::vector<std::byte> buffer_1{10};
   auto bytes_read = *kapi::filesystem::read(fd_1.value(), buffer_1);
   auto buffer_as_str = std::string_view{reinterpret_cast<char *>(buffer_1.data()), bytes_read};
-  kstd::println("--> read {} from /entrance/tickets.txt: {}", bytes_read, buffer_as_str);
-  kstd::println("");
+  kstd::println("[OS:DEM] read {} from /entrance/tickets.txt: {}", bytes_read, buffer_as_str);
 
   // 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");
+  kstd::println("[OS:DEM] trying 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() == kstd::errc::no_such_file_or_directory)
   {
-    kstd::println("--> as expected the file could not be opened before mounting");
+    kstd::println("[OS:DEM] file could not be opened before mounting");
   }
 
   // 4) mount a new filesystem on top of /entrance
-  kstd::println("mount /dev/ram1 to /entrance");
-  if (kapi::filesystem::mount("/dev/ram1", "/entrance"))
+  kstd::println("[OS:DEM] mount /dev/ram1 to /entrance");
+  if (auto result = kapi::filesystem::mount("/dev/ram1", "/entrance"))
   {
-    kstd::println("--> successfully mounted /dev/ram1 to /entrance");
+    kstd::println("[OS:DEM] mounted /dev/ram1 to /entrance");
   }
   else
   {
-    kapi::system::panic("demo failed");
+    kapi::system::panic("[OS:DEM] failed to mount /dev/ram1 on /entrance", result.error());
   }
-  kstd::println("");
 
   // 5) open a file from the new filesystem
-  kstd::println("attempting to open /entrance/information/info_1.txt");
+  kstd::println("[OS:DEM] trying to open /entrance/information/info_1.txt");
   auto fd_2 = kapi::filesystem::open("/entrance/information/info_1.txt");
   if (fd_2)
   {
-    kstd::println("--> successfully opened /entrance/information/info_1.txt with file descriptor {}", fd_2.value());
+    kstd::println("[OS:DEM] opened /entrance/information/info_1.txt with file descriptor {}", fd_2.value());
   }
   else
   {
-    kapi::system::panic("demo failed");
+    kapi::system::panic("[OS:DEM] failed to open /entrance/information/info_1.txt", fd_2.error());
   }
 
   // 6) read from the new file
   kstd::vector<std::byte> buffer_2{10};
   bytes_read = *kapi::filesystem::read(fd_2.value(), buffer_2);
   buffer_as_str = std::string_view{reinterpret_cast<char *>(buffer_2.data()), static_cast<std::size_t>(bytes_read)};
-  kstd::println("--> read {} from /entrance/information/info_1.txt: {}", bytes_read, buffer_as_str);
+  kstd::println("[OS:DEM] read {} from /entrance/information/info_1.txt: {}", bytes_read, buffer_as_str);
 
   // 7) open device as file
-  kstd::println("attempting to open /dev/ram2 as a file");
+  kstd::println("[OS:DEM] trying to open /dev/ram2 as a file");
   auto fd_3 = kapi::filesystem::open("/dev/ram2");
   if (fd_3)
   {
-    kstd::println("--> successfully opened /dev/ram2 as a file with file descriptor {}", fd_3.value());
+    kstd::println("[OS:DEM] opened /dev/ram2 as a file with file descriptor {}", fd_3.value());
   }
   else
   {
-    kapi::system::panic("demo failed");
+    kapi::system::panic("[OS:DEM] failed to open /dev/ram2 as a file", fd_3.error());
   }
 
   // 8) read from the device file
   kstd::vector<std::byte> buffer_3{2};
   bytes_read = *kapi::filesystem::read(fd_3.value(), buffer_3);
-  kstd::println("--> read {} from /dev/ram2: {::#04x}", bytes_read, buffer_3);
+  kstd::println("[OS:DEM] read {} from /dev/ram2: {::#04x}", bytes_read, buffer_3);
 
   // 9) write to the device file
   auto const default_buffer_value = std::byte{0xAA};
   kstd::vector<std::byte> write_buffer{default_buffer_value, default_buffer_value};
   auto bytes_written = *kapi::filesystem::write(fd_3.value(), write_buffer);
-  kstd::println("--> wrote {} to /dev/ram2: {::#04x}", bytes_written, write_buffer);
+  kstd::println("[OS:DEM] wrote {} to /dev/ram2: {::#04x}", bytes_written, write_buffer);
 
   // 10) do memory dump to show that the write to the device file had an effect
 
@@ -119,25 +117,25 @@ auto run_demo() -> void
 
   if (!creation_result)
   {
-    kapi::system::panic("demo failed", creation_result.error());
+    kapi::system::panic("[OS:DEM] failed to create /test_files/test_file.txt", creation_result.error());
   }
 
   // 13) write to the new file
   auto fd_4 = kapi::filesystem::open("/test_files/test_file.txt");
   if (fd_4)
   {
-    kstd::println("--> successfully opened /test_files/test_file.txt as a file with file descriptor {}", fd_4.value());
+    kstd::println("[OS:DEM] opened /test_files/test_file.txt as a file with file descriptor {}", fd_4.value());
   }
   else
   {
-    kapi::system::panic("demo failed");
+    kapi::system::panic("[OS:DEM] failed to open /test_files/test_file.txt", fd_4.error());
   }
 
   kstd::vector<std::byte> test_write_buffer{
     std::byte{'H'}, std::byte{'e'}, std::byte{'l'}, std::byte{'l'}, std::byte{'o'}, std::byte{' '}, std::byte{'T'},
     std::byte{'e'}, std::byte{'a'}, std::byte{'c'}, std::byte{'h'}, std::byte{'O'}, std::byte{'S'}};
   bytes_written = *kapi::filesystem::write(*fd_4, test_write_buffer);
-  kstd::println("--> wrote {} to /test_files/test_file.txt: {::#04x}", bytes_written, test_write_buffer);
+  kstd::println("[OS:DEM] wrote {} to /test_files/test_file.txt: {::#04x}", bytes_written, test_write_buffer);
 
   // 14) dmp the module after create new directory and file
   // -exec monitor memsave 0xffffffff8025b000 0xA00000 dump_after.bin
@@ -146,75 +144,75 @@ auto run_demo() -> void
   auto fd_5 = kapi::filesystem::open("/dev/null");
   if (fd_5)
   {
-    kstd::println("--> successfully opened /dev/null as a file with file descriptor {}", fd_5.value());
+    kstd::println("[OS:DEM] opened /dev/null as a file with file descriptor {}", fd_5.value());
   }
   else
   {
-    kapi::system::panic("demo failed");
+    kapi::system::panic("[OS:DEM] failed to open /dev/null", fd_5.error());
   }
 
   auto buffer_4 = kstd::vector<std::byte>{10, std::byte{0xff}};
   if (auto read = kapi::filesystem::read(fd_5.value(), buffer_4); !read)
   {
-    kapi::system::panic("demo failed: {}", read.error());
+    kapi::system::panic("[OS:DEM] failed to read from /dev/null", read.error());
   }
   else
   {
     bytes_read = *read;
   }
-  kstd::println("--> read {} from /dev/null", bytes_read);
+  kstd::println("[OS:DEM] read {} from /dev/null", bytes_read);
 
   if (auto written = kapi::filesystem::write(fd_5.value(), buffer_4); !written)
   {
-    kapi::system::panic("demo failed: {}", written.error());
+    kapi::system::panic("[OS:DEM] failed to write to /dev/null", written.error());
   }
   else
   {
     bytes_written = *written;
   }
-  kstd::println("--> wrote {} to /dev/null", bytes_written);
+  kstd::println("[OS:DEM] wrote {} to /dev/null", bytes_written);
 
   // 16) read from /dev/null
   auto fd_6 = kapi::filesystem::open("/dev/zero");
   if (fd_6)
   {
-    kstd::println("--> successfully opened /dev/zero as a file with file descriptor {}", fd_6.value());
+    kstd::println("[OS:DEM] opened /dev/zero as a file with file descriptor {}", fd_6.value());
   }
   else
   {
-    kapi::system::panic("demo failed");
+    kapi::system::panic("[OS:DEM] failed to open /dev/zero", fd_6.error());
   }
 
   auto buffer_5 = kstd::vector<std::byte>{10, std::byte{0xff}};
   if (auto read = kapi::filesystem::read(fd_6.value(), buffer_5); !read)
   {
-    kapi::system::panic("demo failed: {}", read.error());
+    kapi::system::panic("[OS:DEM] failed to read from /dev/zero", read.error());
   }
   else
   {
     bytes_read = *read;
   }
-  kstd::println("--> read {} from /dev/zero: {::#04x}", bytes_read, buffer_5);
+  kstd::println("[OS:DEM] read {} from /dev/zero: {::#04x}", bytes_read, buffer_5);
 
   if (auto written = kapi::filesystem::write(fd_6.value(), buffer_5); !written)
   {
-    kapi::system::panic("demo failed: {}", written.error());
+    kapi::system::panic("[OS:DEM] failed to write to /dev/zero", written.error());
   }
   else
   {
     bytes_written = *written;
   }
-  kstd::println("--> wrote {} to /dev/zero", bytes_written);
+  kstd::println("[OS:DEM] wrote {} to /dev/zero", bytes_written);
 
   auto ls = [](std::string_view path) {
     auto fd = kapi::filesystem::open(path);
     if (fd)
     {
-      kstd::println("--> ls '{}'", path);
+      kstd::println("[OS:DEM] ls '{}'", path);
     }
     else
     {
-      kstd::println(kstd::print_sink::stderr, "!!> ls '{}': {}", path, fd.error());
+      kstd::println(kstd::print_sink::stderr, "[OS:DEM] ls '{}': {}", path, fd.error());
       return;
     }
 
@@ -232,7 +230,7 @@ auto run_demo() -> void
         }
         else
         {
-          kstd::println(kstd::print_sink::stderr, "!!> ls '{}': {}", path, stat.error());
+          kstd::println(kstd::print_sink::stderr, "[OS:DEM] ls '{}': {}", path, stat.error());
         }
       }
     }
@@ -246,12 +244,12 @@ auto run_demo() -> void
       }
       else
       {
-        kstd::println(kstd::print_sink::stderr, "!!> ls '{}': {}", path, stat.error());
+        kstd::println(kstd::print_sink::stderr, "[OS:DEM] ls '{}': {}", path, stat.error());
       }
     }
     else
     {
-      kstd::println(kstd::print_sink::stderr, "!!> ls '{}': {}", path, read.error());
+      kstd::println(kstd::print_sink::stderr, "[OS:DEM] ls '{}': {}", path, read.error());
       return;
     }
   };
@@ -316,5 +314,5 @@ auto main() -> int
   // TODO BA-FS26 remove demo code?
   run_demo();
 
-  kapi::system::panic("Returning from kernel main!");
+  kapi::system::panic("[OS] Returning from kernel main!");
 }