kernel/filesystems: copy and rename rootfs to fat32

8 files changed, 282 insertions, 0 deletions

diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
index 341f396a..e7464658 100644
--- a/kernel/CMakeLists.txt
+++ b/kernel/CMakeLists.txt
@@ -85,6 +85,11 @@ target_sources("kernel_lib" PRIVATE
     "kernel/filesystems/ext2/module.cpp"
     "kernel/filesystems/ext2/write_batch.cpp"
 
+    # fat32 Filesystem
+    "kernel/filesystems/fat32/filesystem.cpp"
+    "kernel/filesystems/fat32/inode.cpp"
+    "kernel/filesystems/fat32/module.cpp"
+
     # Rootfs Filesystem
     "kernel/filesystems/rootfs/filesystem.cpp"
     "kernel/filesystems/rootfs/inode.cpp"
diff --git a/kernel/kernel/filesystems/fat32/filesystem.cpp b/kernel/kernel/filesystems/fat32/filesystem.cpp
new file mode 100644
index 00000000..a66a9b25
--- /dev/null
+++ b/kernel/kernel/filesystems/fat32/filesystem.cpp
@@ -0,0 +1,47 @@
+#include <kernel/filesystems/fat32/filesystem.hpp>
+
+#include <kernel/filesystems/fat32/inode.hpp>
+#include <kernel/vfs/error.hpp>
+#include <kernel/vfs/filesystem.hpp>
+
+#include <kapi/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/result.hpp>
+#include <kstd/system_error.hpp>
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+namespace kernel::filesystems::fat32
+{
+  static_assert(sizeof(kernel::vfs::filesystem) == sizeof(fat32::filesystem));
+
+  auto filesystem::probe(inode_ptr const & inode) const -> kstd::result<std::uint32_t>
+  {
+    if (inode)
+    {
+      return kstd::failure(vfs::errc::invalid_argument);
+    }
+
+    return 0;
+  }
+
+  auto filesystem::mount(inode_ptr const &) -> kstd::result<mount_result>
+  {
+    auto root = kstd::make_shared<inode>();
+    return mount_result{root, nullptr};
+  }
+
+  auto filesystem::lookup(inode_ptr const &, std::string_view, driver_data_ptr) const -> kstd::result<inode_ptr>
+  {
+    return kstd::failure(vfs::errc::no_such_file_or_directory);
+  }
+
+  auto filesystem::create_inode(inode_ptr const &, std::string_view, kapi::filesystem::file_type, driver_data_ptr,
+                                std::optional<kapi::filesystem::device_number>) -> kstd::result<inode_ptr>
+  {
+    return kstd::failure(vfs::errc::read_only_file_system);
+  }
+}  // namespace kernel::filesystems::fat32
diff --git a/kernel/kernel/filesystems/fat32/filesystem.hpp b/kernel/kernel/filesystems/fat32/filesystem.hpp
new file mode 100644
index 00000000..8b0b4941
--- /dev/null
+++ b/kernel/kernel/filesystems/fat32/filesystem.hpp
@@ -0,0 +1,38 @@
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_FAT32_FILESYSTEM_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_FAT32_FILESYSTEM_HPP
+
+#include <kernel/vfs/filesystem.hpp>
+#include <kernel/vfs/inode.hpp>
+
+#include <kapi/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/result.hpp>
+#include <kstd/string.hpp>
+#include <kstd/system_error.hpp>
+#include <kstd/vector.hpp>
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+namespace kernel::filesystems::fat32
+{
+  //! The File Allocation Table 32 Filesystem (fat32)
+  struct filesystem : kernel::vfs::filesystem
+  {
+    [[nodiscard]] auto probe(inode_ptr const & inode) const -> kstd::result<std::uint32_t> override;
+
+    auto mount(inode_ptr const & backing_inode) -> kstd::result<mount_result> override;
+
+    [[nodiscard]] auto lookup(inode_ptr const & parent, std::string_view name, driver_data_ptr driver_data) const
+        -> kstd::result<inode_ptr> override;
+
+    [[nodiscard]] auto create_inode(inode_ptr const & parent, std::string_view name, kapi::filesystem::file_type type,
+                                    driver_data_ptr driver_data,
+                                    std::optional<kapi::filesystem::device_number> raw_device = std::nullopt)
+        -> kstd::result<inode_ptr> override;
+  };
+}  // namespace kernel::filesystems::fat32
+
+#endif
\ No newline at end of file
diff --git a/kernel/kernel/filesystems/fat32/filesystem.tests.cpp b/kernel/kernel/filesystems/fat32/filesystem.tests.cpp
new file mode 100644
index 00000000..cc35cd74
--- /dev/null
+++ b/kernel/kernel/filesystems/fat32/filesystem.tests.cpp
@@ -0,0 +1,48 @@
+#include <kernel/filesystems/fat32/filesystem.hpp>
+
+#include <kernel/vfs/filesystem.hpp>
+
+#include <kapi/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/print.hpp>
+#include <kstd/vector.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("fat32 filesystem mount and lookup", "[filesystem][fat32][filesystem]")
+{
+  GIVEN("a mounted fat32 filesystem")
+  {
+    auto fs = kstd::make_shared<kernel::filesystems::fat32::filesystem>();
+    auto mount = fs->mount(nullptr);
+    REQUIRE(mount);
+    auto [root, driver_data] = *mount;
+    REQUIRE(root);
+
+    THEN("the filesystem can be mounted successfully")
+    {
+      REQUIRE(mount);
+    }
+
+    THEN("looking up a non-existent directory returns an error")
+    {
+      auto non_existent_inode_1 = fs->lookup(root, "", driver_data);
+      REQUIRE(!non_existent_inode_1);
+      auto non_existent_inode_2 = fs->lookup(root, "nonexistent", driver_data);
+      REQUIRE(!non_existent_inode_2);
+    }
+
+    THEN("looking up with a null parent inode returns an error")
+    {
+      auto result = fs->lookup(nullptr, "dev", driver_data);
+      REQUIRE(!result);
+    }
+
+    THEN("create_inode always returns an error")
+    {
+      auto result = fs->create_inode(root, "new_device", kapi::filesystem::file_type::directory, driver_data);
+      REQUIRE(!result);
+    }
+  }
+}
diff --git a/kernel/kernel/filesystems/fat32/inode.cpp b/kernel/kernel/filesystems/fat32/inode.cpp
new file mode 100644
index 00000000..993256df
--- /dev/null
+++ b/kernel/kernel/filesystems/fat32/inode.cpp
@@ -0,0 +1,37 @@
+#include <kernel/vfs/inode.hpp>
+
+#include <kernel/filesystems/fat32/inode.hpp>
+
+#include <kapi/filesystem.hpp>
+
+#include <kstd/result.hpp>
+#include <kstd/units.hpp>
+
+#include <cstddef>
+#include <span>
+#include <utility>
+
+namespace kernel::filesystems::fat32
+{
+  auto inode::read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes>
+  {
+    return kstd::bytes{};
+  }
+
+  auto inode::write(std::span<std::byte const>, kstd::bytes) -> kstd::result<kstd::bytes>
+  {
+    return kstd::bytes{};
+  }
+
+  auto inode::is_directory() const -> bool
+  {
+    return true;
+  }
+
+  auto inode::read_directory(kapi::filesystem::directory_cursor position,
+                             std::span<kapi::filesystem::directory_entry>) const
+      -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>>
+  {
+    return std::pair{0, position};
+  }
+}  // namespace kernel::filesystems::fat32
diff --git a/kernel/kernel/filesystems/fat32/inode.hpp b/kernel/kernel/filesystems/fat32/inode.hpp
new file mode 100644
index 00000000..3f9ae37e
--- /dev/null
+++ b/kernel/kernel/filesystems/fat32/inode.hpp
@@ -0,0 +1,37 @@
+#ifndef TEACHOS_KERNEL_FILESYSTEMS_FAT32_INODE_HPP
+#define TEACHOS_KERNEL_FILESYSTEMS_FAT32_INODE_HPP
+
+#include <kernel/vfs/inode.hpp>
+
+#include <kapi/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/result.hpp>
+#include <kstd/string.hpp>
+#include <kstd/units.hpp>
+#include <kstd/vector.hpp>
+
+#include <cstddef>
+#include <span>
+#include <utility>
+
+namespace kernel::filesystems::fat32
+{
+  //! An inode in the fat32 filesystem.
+  struct inode : kernel::vfs::inode
+  {
+    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> override;
+
+    [[nodiscard]] auto write(std::span<std::byte const> buffer, kstd::bytes offset)
+        -> kstd::result<kstd::bytes> override;
+
+    [[nodiscard]] auto is_directory() const -> bool override;
+
+    [[nodiscard]] auto read_directory(kapi::filesystem::directory_cursor position,
+                                      std::span<kapi::filesystem::directory_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>> override;
+  };
+}  // namespace kernel::filesystems::fat32
+
+#endif
diff --git a/kernel/kernel/filesystems/fat32/inode.tests.cpp b/kernel/kernel/filesystems/fat32/inode.tests.cpp
new file mode 100644
index 00000000..7e151d9f
--- /dev/null
+++ b/kernel/kernel/filesystems/fat32/inode.tests.cpp
@@ -0,0 +1,42 @@
+#include <kernel/filesystems/rootfs/inode.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/print.hpp>
+#include <kstd/units.hpp>
+#include <kstd/vector.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <cstddef>
+
+using namespace kstd::units_literals;
+
+SCENARIO("Rootfs inode read/write", "[filesystem][rootfs][inode]")
+{
+  GIVEN("a rootfs inode")
+  {
+    auto inode = kernel::filesystems::rootfs::inode{};
+
+    WHEN("reading from the inode")
+    {
+      kstd::vector<std::byte> buffer(10);
+      auto bytes_read = inode.read(buffer, 0_B);
+
+      THEN("no bytes are read")
+      {
+        REQUIRE(bytes_read == 0_B);
+      }
+    }
+
+    WHEN("writing to the inode")
+    {
+      kstd::vector<std::byte> buffer(10, std::byte{'x'});
+      auto bytes_written = inode.write(buffer, 0_B);
+
+      THEN("no bytes are written")
+      {
+        REQUIRE(bytes_written == 0_B);
+      }
+    }
+  }
+}
diff --git a/kernel/kernel/filesystems/fat32/module.cpp b/kernel/kernel/filesystems/fat32/module.cpp
new file mode 100644
index 00000000..c3cbb9d6
--- /dev/null
+++ b/kernel/kernel/filesystems/fat32/module.cpp
@@ -0,0 +1,28 @@
+#include <kernel/filesystems/fat32/filesystem.hpp>
+#include <kernel/vfs/driver_registry.hpp>
+#include <kernel/vfs/filesystem.hpp>
+
+#include <kstd/memory.hpp>
+
+#include <string_view>
+
+namespace
+{
+
+  struct descriptor final : kernel::vfs::driver_descriptor
+  {
+    [[nodiscard]] auto name() const noexcept -> std::string_view override
+    {
+      return "fat32";
+    }
+
+    [[nodiscard]] auto make_instance() const -> kernel::vfs::filesystem::filesystem_ptr override
+    {
+      return kstd::make_shared<kernel::filesystems::fat32::filesystem>();
+    }
+  };
+
+  [[gnu::used]]
+  constexpr auto registration = kernel::vfs::driver_module<descriptor>{};
+
+}  // namespace
\ No newline at end of file