kernel/tests: clean up fake memory implementation

3 files changed, 88 insertions, 92 deletions

diff --git a/kernel/src/test_support/kapi/memory.cpp b/kernel/src/test_support/kapi/memory.cpp
index 652a3d3..7b7a81e 100644
--- a/kernel/src/test_support/kapi/memory.cpp
+++ b/kernel/src/test_support/kapi/memory.cpp
@@ -2,15 +2,12 @@
 
 #include <kapi/memory.hpp>
 
-#include "kernel/tests/simulated_memory.hpp"
+#include "kernel/tests/bump_frame_allocator.hpp"
+#include "kernel/tests/page_mapper.hpp"
 
-#include <kstd/print>
 #include <kstd/units>
 
-#include <cstddef>
-#include <cstdint>
 #include <optional>
-#include <utility>
 
 namespace kapi::memory
 {
@@ -18,97 +15,48 @@ namespace kapi::memory
   namespace
   {
     //! The size of the simulated RAM.
-    constexpr auto simulate_memory_size = kstd::units::MiB(32);
-    constexpr auto number_of_simulated_frames = simulate_memory_size / frame::size;
+    constexpr auto memory_size = kstd::units::MiB(32);
+    constexpr auto number_of_frames = memory_size / frame::size;
 
-    struct test_bootstrap_frame_allocator : frame_allocator
-    {
-      auto mark_used(frame) -> void override {}
-
-      auto allocate_many(std::size_t count) noexcept -> std::optional<std::pair<frame, std::size_t>> override
-      {
-        auto start = next_free_frame;
-        next_free_frame += count;
-        return std::pair{frame{start}, count};
-      }
-
-      auto release_many(std::pair<frame, std::size_t>) -> void override {}
+    auto constinit bump_allocator = std::optional<kernel::tests::bump_frame_allocator>{};
+    auto constinit test_mapper = std::optional<kernel::tests::page_mapper>{};
 
-      std::size_t next_free_frame{};
-    };
-
-    auto constinit bootstrap_allocator = std::optional<test_bootstrap_frame_allocator>{};
-
-    struct test_page_mapper : page_mapper
-    {
-      auto map(page page, frame frame, flags flags) -> std::byte * override
-      {
-        kstd::println("mapping page {} onto frame {} with flags {}", page.number(), frame.number(),
-                      static_cast<std::uint64_t>(flags));
-
-        if ((page.start_address() & pmm_metadata_base.raw()) == pmm_metadata_base.raw())
-        {
-          auto offset = page.start_address() & ~pmm_metadata_base.raw();
-          return kernel::tests::simulated_memory::pmm_metadata_base() + offset;
-        }
-
-        return nullptr;
-      }
-
-      auto unmap(page page) -> void override
-      {
-        kstd::println("unmapping page {}", page.number());
-      }
-
-      auto try_unmap(page page) noexcept -> bool override
-      {
-        kstd::println("trying to unmap page {}", page.number());
-        return false;
-      }
-    };
-
-    auto constinit test_mapper = std::optional<test_page_mapper>{};
+    auto constinit old_allocator = std::optional<frame_allocator *>{};
+    auto constinit old_mapper = std::optional<page_mapper *>{};
 
     auto handoff_to_kernel_pmm(frame_allocator & new_allocator) -> void
     {
-      auto first_free_frame = bootstrap_allocator->next_free_frame;
-      auto number_of_free_frames = number_of_simulated_frames - first_free_frame;
+      auto first_free_frame = bump_allocator->next_free_frame;
+      auto number_of_free_frames = number_of_frames - first_free_frame;
       new_allocator.release_many({frame{first_free_frame}, number_of_free_frames});
     }
 
-    auto constinit previous_frame_allocator = std::optional<frame_allocator *>{};
-    auto constinit previous_page_mapper = std::optional<page_mapper *>{};
-
   }  // namespace
 
   auto init() -> void
   {
-    kernel::tests::simulated_memory::init(simulate_memory_size);
+    bump_allocator.emplace();
+    test_mapper.emplace(memory_size);
 
-    bootstrap_allocator.emplace();
-    test_mapper.emplace();
+    old_allocator = set_frame_allocator(*bump_allocator);
+    old_mapper = set_page_mapper(*test_mapper);
 
-    previous_frame_allocator = set_frame_allocator(*bootstrap_allocator);
-    previous_page_mapper = set_page_mapper(*test_mapper);
-
-    init_pmm(simulate_memory_size / frame::size, handoff_to_kernel_pmm);
+    init_pmm(memory_size / frame::size, handoff_to_kernel_pmm);
   }
 
   auto reset() -> void
   {
-    kernel::tests::simulated_memory::reset();
-
-    if (previous_frame_allocator && *previous_frame_allocator)
+    if (old_allocator && *old_allocator)
     {
-      set_frame_allocator(**previous_frame_allocator);
+      set_frame_allocator(**old_allocator);
     }
 
-    if (previous_page_mapper && *previous_page_mapper)
+    if (old_mapper && *old_mapper)
     {
-      set_page_mapper(**previous_page_mapper);
+      set_page_mapper(**old_mapper);
     }
 
-    bootstrap_allocator.reset();
+    bump_allocator.reset();
     test_mapper.reset();
   }
 
diff --git a/kernel/src/test_support/page_mapper.cpp b/kernel/src/test_support/page_mapper.cpp
new file mode 100644
index 0000000..a026ec3
--- /dev/null
+++ b/kernel/src/test_support/page_mapper.cpp
@@ -0,0 +1,57 @@
+#include "kernel/tests/page_mapper.hpp"
+
+#include "kapi/memory.hpp"
+
+#include <kstd/units>
+
+#include <cstddef>
+#include <format>
+#include <stdexcept>
+
+namespace kernel::tests
+{
+
+  page_mapper::page_mapper(kstd::units::bytes memory_size)
+      : memory{memory_size}
+  {}
+
+  auto page_mapper::map(kapi::memory::page page, kapi::memory::frame frame, flags) -> std::byte *
+  {
+    page_mappings.insert({page.number(), frame});
+
+    auto page_address = page.start_address();
+
+    if (page_address >= kapi::memory::mmio_base)
+    {
+      throw std::invalid_argument{"MMIO mapping not yet supported in testing!"};
+    }
+    else if (page_address >= kapi::memory::higher_half_direct_map_base)
+    {
+      auto offset = frame.number() * kapi::memory::frame::size;
+      return memory.ram_base() + offset;
+    }
+
+    return nullptr;
+  }
+
+  auto page_mapper::unmap(kapi::memory::page page) -> void
+  {
+    if (!try_unmap(page))
+    {
+      auto error = std::format("Page {} was never mapped!", page.number());
+      throw std::invalid_argument{error};
+    }
+  }
+
+  auto page_mapper::try_unmap(kapi::memory::page page) noexcept -> bool
+  {
+    if (page_mappings.contains(page.number()))
+    {
+      page_mappings.erase(page.number());
+      return true;
+    }
+
+    return false;
+  }
+
+}  // namespace kernel::tests
\ No newline at end of file
diff --git a/kernel/src/test_support/simulated_memory.cpp b/kernel/src/test_support/simulated_memory.cpp
index 49e172f..d23350b 100644
--- a/kernel/src/test_support/simulated_memory.cpp
+++ b/kernel/src/test_support/simulated_memory.cpp
@@ -5,35 +5,26 @@
 #include <cstddef>
 #include <vector>
 
-namespace kernel::tests::simulated_memory
+namespace kernel::tests
 {
 
-  namespace
-  {
-    auto constinit ram_storage = std::vector<std::byte>{};
-    auto constinit pmm_storage = std::vector<std::byte>{};
-  }  // namespace
-
-  auto init(kstd::units::bytes size) -> void
-  {
-    ram_storage.resize(size / kstd::units::bytes{1});
-    pmm_storage.resize(size / kstd::units::bytes{1});
-  }
+  simulated_memory::simulated_memory(kstd::units::bytes size)
+      : m_memory{size / kstd::units::bytes{1}}
+  {}
 
-  auto reset() -> void
+  auto simulated_memory::ram_base() noexcept -> std::byte *
   {
-    ram_storage.clear();
-    pmm_storage.clear();
+    return m_memory.data();
   }
 
-  auto pmm_metadata_base() -> std::byte *
+  auto simulated_memory::ram_base() const noexcept -> std::byte const *
   {
-    return pmm_storage.data();
+    return m_memory.data();
   }
 
-  auto ram_base() -> std::byte *
+  auto simulated_memory::clear() -> void
   {
-    return ram_storage.data();
+    m_memory.clear();
   }
 
-}  // namespace kernel::tests::simulated_memory
\ No newline at end of file
+}  // namespace kernel::tests
\ No newline at end of file