1 files changed, 104 insertions, 24 deletions

diff --git a/kernel/src/main.cpp b/kernel/src/main.cpp
index 6434045..bb6d57d 100644
--- a/kernel/src/main.cpp
+++ b/kernel/src/main.cpp
@@ -6,29 +6,41 @@
 #include "kapi/system.hpp"
 
 #include "kernel/devices/storage/storage_management.hpp"
-#include "kernel/filesystem/device_file.hpp"
+#include "kernel/filesystem/device_inode.hpp"
+#include "kernel/filesystem/ext2/ext2_filesystem.hpp"
 #include "kernel/filesystem/file_descriptor_table.hpp"
 #include "kernel/filesystem/open_file_description.hpp"
 #include "kernel/filesystem/vfs.hpp"
 #include "kernel/memory.hpp"
 
+#include <kstd/format>
 #include <kstd/memory>
 #include <kstd/os/error.hpp>
 #include <kstd/print>
 #include <kstd/vector>
 
+#include <algorithm>
 #include <cstddef>
-#include <cstdint>
 
-auto run_test_code() -> void
+auto test_device_names() -> void
+{
+  auto storage_mgmt = devices::storage::storage_management::get();
+  std::ranges::for_each(storage_mgmt.all_controllers(), [](auto const & controller) {
+    std::ranges::for_each(controller->all_devices(),
+                          [](auto const & device) { kstd::println("{}", device->name().view()); });
+  });
+}
+
+auto test_file_description_manually() -> void
 {
   // setup
   auto fd_table = filesystem::file_descriptor_table::get();
   auto storage_mgmt = devices::storage::storage_management::get();
   auto device = storage_mgmt.device_by_major_minor(1, 0);
 
-  auto dev_file = kstd::make_shared<filesystem::device_file>(device);
-  filesystem::open_file_description ofd(dev_file);
+  auto dev_node = kstd::make_shared<filesystem::device_inode>(device);
+
+  auto ofd = kstd::make_shared<filesystem::open_file_description>(dev_node);
   auto fd_index = fd_table.add_file(ofd);
 
   // use: read two bytes and write two again
@@ -40,17 +52,8 @@ auto run_test_code() -> void
 
   kstd::vector<std::byte> buffer{2};
   auto number_of_read_bytes = fd->read(buffer.data(), buffer.size());
-
-  for (size_t i = 0; i < number_of_read_bytes; ++i)
-  {
-    kstd::print("{:02x} ", static_cast<uint8_t>(buffer[i]));
-
-    if ((i + 1) % 16 == 0)
-    {
-      kstd::println("");
-    }
-  }
-  kstd::println("---");
+  kstd::println("read bytes: {}", number_of_read_bytes);
+  kstd::println("buffer: {::#04x}", buffer);
 
   // write half of the file new
   auto const value1 = std::byte{0xAA};
@@ -63,7 +66,7 @@ auto run_test_code() -> void
   fd_table.remove_file(fd_index);
 
   // use: read four bytes again -> two old bytes two new bytes
-  filesystem::open_file_description ofd1(dev_file);
+  auto ofd1 = kstd::make_shared<filesystem::open_file_description>(dev_node);
   fd_index = fd_table.add_file(ofd1);
   auto fd1 = fd_table.get_file(fd_index);
 
@@ -74,17 +77,93 @@ auto run_test_code() -> void
 
   kstd::vector<std::byte> buffer1{4};
   number_of_read_bytes = fd1->read(buffer1.data(), buffer1.size());
+  kstd::println("read bytes: {}", number_of_read_bytes);
+  kstd::println("buffer: {::#04x}", buffer1);
+}
+
+auto test_device_with_vfs() -> void
+{
+  // TODO BA-FS26
+
+  auto vfs = filesystem::vfs::get();
+  auto ofd = vfs.open("/dev/ram0");
+  if (!ofd)
+  {
+    kstd::os::panic("test code failed");
+  }
+
+  auto fd_table = filesystem::file_descriptor_table::get();
+  auto fd = fd_table.add_file(ofd);
+  kstd::vector<std::byte> buffer{2};
+  auto file = fd_table.get_file(fd);
+  if (!file)
+  {
+    kstd::os::panic("test code failed");
+  }
+
+  auto number_of_read_bytes = file->read(buffer.data(), buffer.size());
+  kstd::println("read bytes: {}", number_of_read_bytes);
+  kstd::println("buffer: {::#04x}", buffer);
+}
+
+auto test_file_lookup() -> void
+{
+  // TODO BA-FS26 implement a more complete test with multiple files and directories and mounts etc.
+
+  auto vfs = filesystem::vfs::get();
+  auto storage_mgmt = devices::storage::storage_management::get();
+
+  auto ofd1 = vfs.open("/a/b/c");
+  auto ofd2 = vfs.open("/dev/ram0");
+  auto ofd3 = vfs.open("/a/d/e");
+  if (!ofd1 || !ofd2 || !ofd3)
+  {
+    kstd::os::panic("test code failed");
+  }
 
-  for (size_t i = 0; i < number_of_read_bytes; ++i)
+  if (auto ofd4 = vfs.open("/dev/xxx"))
+  {
+    kstd::os::panic("test code failed");
+  }
+
+  auto new_filesystem = kstd::make_shared<filesystem::ext2::ext2_filesystem>();
+  auto device = storage_mgmt.device_by_major_minor(1, 16);
+  new_filesystem->mount(device);
+  if (vfs.do_mount("/a/b", new_filesystem) != 0)
+  {
+    kstd::os::panic("test code failed");
+  }
+  auto ofd5 = vfs.open("/a/b/c");
+  if (!ofd5)
   {
-    kstd::print("{:02x} ", static_cast<uint8_t>(buffer1[i]));
+    kstd::os::panic("test code failed");
+  }
 
-    if ((i + 1) % 16 == 0)
-    {
-      kstd::println("");
-    }
+  if (auto ofd6 = vfs.open("x/y/z"))
+  {
+    kstd::os::panic("test code failed");
   }
-  kstd::println("---");
+}
+
+auto run_test_code() -> void
+{
+  kstd::println("[TEST] Running test code...");
+
+  kstd::println("[TEST] device names");
+  test_device_names();
+  kstd::println("---------------------------------");
+
+  kstd::println("[TEST] file description manually");
+  test_file_description_manually();
+  kstd::println("---------------------------------");
+
+  kstd::println("[TEST] device with VFS");
+  test_device_with_vfs();
+  kstd::println("---------------------------------");
+
+  kstd::println("[TEST] file lookup");
+  test_file_lookup();
+  kstd::println("---------------------------------");
 }
 
 auto main() -> int
@@ -113,6 +192,7 @@ auto main() -> int
   kstd::println("[OS] Virtual filesystem initialized.");
 
   run_test_code();
+  kstd::println("[TEST] All tests completed.");
 
   kapi::system::panic("Returning from kernel main!");
 }