kapi: extract page_mapper interface

5 files changed, 116 insertions, 109 deletions

diff --git a/arch/x86_64/src/kapi/memory.cpp b/arch/x86_64/src/kapi/memory.cpp
index ed3edef..00b9de3 100644
--- a/arch/x86_64/src/kapi/memory.cpp
+++ b/arch/x86_64/src/kapi/memory.cpp
@@ -13,6 +13,7 @@
 #include "x86_64/memory/page_table.hpp"
 #include "x86_64/memory/page_utilities.hpp"
 #include "x86_64/memory/paging_root.hpp"
+#include "x86_64/memory/recursive_page_mapper.hpp"
 #include "x86_64/memory/region_allocator.hpp"
 #include "x86_64/memory/scoped_mapping.hpp"
 
@@ -29,6 +30,8 @@ namespace teachos::memory
   {
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     auto constinit allocator = static_cast<frame_allocator *>(nullptr);
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+    auto constinit mapper = static_cast<page_mapper *>(nullptr);
 
     constexpr auto static unused_page_address = linear_address{0x0000'7fff'cafe'faceuz};
     constexpr auto static recursive_page_map_index = x86_64::page_table::entry_count - 2;
@@ -70,7 +73,7 @@ namespace teachos::memory
 
       auto page = page::containing(unused_page_address);
 
-      auto temporary_mapper = scoped_mapping{page, allocator};
+      auto temporary_mapper = scoped_mapping{page};
       auto new_pml4_frame = allocator.allocate();
 
       auto pml4 = std::construct_at(temporary_mapper.map_as<page_table>(*new_pml4_frame, entry_flags::writable));
@@ -124,6 +127,15 @@ namespace teachos::memory
     return *allocator;
   }
 
+  auto active_mapper() -> page_mapper &
+  {
+    if (!mapper)
+    {
+      system::panic("[x86_64] The page mapper has not been set you.");
+    }
+    return *mapper;
+  }
+
   auto init() -> void
   {
     auto static constinit is_initialized = std::atomic_flag{};
@@ -132,14 +144,19 @@ namespace teachos::memory
       system::panic("[x86_64] Memory management has already been initialized.");
     }
 
-    auto allocator = create_early_frame_allocator();
     enable_cpu_protections();
 
-    auto allocation_buffer = x86_64::buffered_allocator<4>{&allocator};
+    auto early_allocator = create_early_frame_allocator();
+    auto allocation_buffer = x86_64::buffered_allocator<4>{&early_allocator};
+    allocator = &allocation_buffer;
+
+    auto recursive_mapper = x86_64::recursive_page_mapper{allocation_buffer};
+    mapper = &recursive_mapper;
+
     auto new_pml4_frame = inject_faux_pml4(allocation_buffer);
 
-    auto mapper = x86_64::kernel_mapper{allocation_buffer, boot::bootstrap_information.mbi};
-    mapper.remap_kernel();
+    auto kernel_mapper = x86_64::kernel_mapper{boot::bootstrap_information.mbi};
+    kernel_mapper.remap_kernel();
     cio::println("[x86_64:MEM] prepared new kernel image page maps.");
 
     auto cr3 = cpu::x86_64::cr3::read();
@@ -149,6 +166,8 @@ namespace teachos::memory
     // remap_heap(heap::KERNEL_HEAP_START, heap::KERNEL_HEAP_SIZE);
     // video::vga::text::write("Heap remapping successful", video::vga::text::common_attributes::green_on_black);
     // video::vga::text::newline();
+    mapper = nullptr;
+    allocator = nullptr;
   }
 
 }  // namespace teachos::memory
diff --git a/arch/x86_64/src/memory/kernel_mapper.cpp b/arch/x86_64/src/memory/kernel_mapper.cpp
index b1d12a4..f46b5b5 100644
--- a/arch/x86_64/src/memory/kernel_mapper.cpp
+++ b/arch/x86_64/src/memory/kernel_mapper.cpp
@@ -32,9 +32,8 @@ namespace teachos::memory::x86_64
 
   }  // namespace
 
-  kernel_mapper::kernel_mapper(frame_allocator & allocator, multiboot2::information_view const * mbi)
-      : m_allocator{&allocator}
-      , m_mbi(std::move(mbi))
+  kernel_mapper::kernel_mapper(multiboot2::information_view const * mbi)
+      : m_mbi{std::move(mbi)}
       , m_kernel_load_base{std::bit_cast<std::uintptr_t>(&boot::x86_64::TEACHOS_VMA)}
   {}
 
@@ -100,7 +99,7 @@ namespace teachos::memory::x86_64
 
     for (auto i = 0uz; i < number_of_pages; ++i)
     {
-      paging_root::get().map(page{first_page.number() + i}, frame{first_frame.number() + i}, page_flags, *m_allocator);
+      paging_root::get().map(page{first_page.number() + i}, frame{first_frame.number() + i}, page_flags);
     }
   }
 
diff --git a/arch/x86_64/src/memory/paging_root.cpp b/arch/x86_64/src/memory/paging_root.cpp
index 5ca2bf0..c458093 100644
--- a/arch/x86_64/src/memory/paging_root.cpp
+++ b/arch/x86_64/src/memory/paging_root.cpp
@@ -27,16 +27,15 @@ namespace teachos::memory::x86_64
     //! still enforcing non-writability and non-execution of the affected page.
     template<std::size_t Level>
       requires(Level > 1uz && Level < 5uz)
-    auto do_map(recursive_page_table<Level> * pml, page page, page_table::entry::flags flags,
-                frame_allocator & allocator)
+    auto do_map(recursive_page_table<Level> * pml, page page, page_table::entry::flags flags)
     {
       auto index = pml_index<Level>(page);
       flags = flags & ~page_table::entry::flags::no_execute;
       flags = flags | page_table::entry::flags::writable;
       if (!(*pml)[index].present())
       {
-        auto new_table_frame = allocator.allocate();
-        auto mapping = scoped_mapping{page, allocator};
+        auto new_table_frame = active_allocator().allocate();
+        auto mapping = scoped_mapping{page};
         (*pml)[index].frame(new_table_frame.value(), page_table::entry::flags::present | flags);
         auto new_table = std::optional{std::construct_at(*pml->next(index))};
         return new_table;
@@ -114,14 +113,49 @@ namespace teachos::memory::x86_64
         .or_else(handle_huge_page);
   }
 
-  auto paging_root::map(page page, frame frame, page_table::entry::flags flags, frame_allocator & allocator)
-      -> std::optional<std::byte *>
+  auto paging_root::map(page page, frame frame, page_table::entry::flags flags) -> std::optional<std::byte *>
   {
     return std::optional{this}
-        .and_then([&](auto pml) -> auto { return do_map(pml, page, flags, allocator); })
-        .and_then([&](auto pml) -> auto { return do_map(pml, page, flags, allocator); })
-        .and_then([&](auto pml) -> auto { return do_map(pml, page, flags, allocator); })
+        .and_then([&](auto pml) -> auto { return do_map(pml, page, flags); })
+        .and_then([&](auto pml) -> auto { return do_map(pml, page, flags); })
+        .and_then([&](auto pml) -> auto { return do_map(pml, page, flags); })
         .and_then([&](auto pml) -> auto { return do_map(pml, page, frame, flags); });
   }
 
+  auto paging_root::unmap(page page) -> void
+  {
+    if (!this->translate(page))
+    {
+      system::panic("[x86_64:MEM] Tried to unmap a page that was not mapped.");
+    }
+
+    auto pml4 = this;
+    auto pml3 = pml4->next(pml_index<4>(page)).value();
+    auto pml2 = pml3->next(pml_index<3>(page)).value();
+    auto pml1 = pml2->next(pml_index<2>(page)).value();
+
+    (*pml1)[pml_index<1>(page)].clear();
+
+    if (pml1->empty())
+    {
+      auto pml1_frame = (*pml2)[pml_index<2>(page)].frame().value();
+      active_allocator().release(pml1_frame);
+      (*pml2)[pml_index<2>(page)].clear();
+    }
+
+    if (pml2->empty())
+    {
+      auto pml2_frame = (*pml3)[pml_index<3>(page)].frame().value();
+      active_allocator().release(pml2_frame);
+      (*pml3)[pml_index<3>(page)].clear();
+    }
+
+    if (pml3->empty())
+    {
+      auto pml3_frame = (*pml4)[pml_index<4>(page)].frame().value();
+      active_allocator().release(pml3_frame);
+      (*pml4)[pml_index<4>(page)].clear();
+    }
+  }
+
 }  // namespace teachos::memory::x86_64
\ No newline at end of file
diff --git a/arch/x86_64/src/memory/recursive_page_mapper.cpp b/arch/x86_64/src/memory/recursive_page_mapper.cpp
new file mode 100644
index 0000000..ea89f38
--- /dev/null
+++ b/arch/x86_64/src/memory/recursive_page_mapper.cpp
@@ -0,0 +1,38 @@
+#include "x86_64/memory/recursive_page_mapper.hpp"
+
+#include "kapi/system.hpp"
+
+#include "x86_64/memory/page_table.hpp"
+#include "x86_64/memory/paging_root.hpp"
+
+namespace teachos::memory::x86_64
+{
+  recursive_page_mapper::recursive_page_mapper(frame_allocator & allocator)
+      : m_allocator{&allocator}
+  {}
+
+  auto recursive_page_mapper::map(page page, frame frame, flags flags) -> std::byte *
+  {
+    return paging_root::get().map(page, frame, to_table_flags(flags)).value_or(nullptr);
+  }
+
+  auto recursive_page_mapper::unmap(page page) -> void
+  {
+    if (!try_unmap(page))
+    {
+      system::panic("[x86_64:MEM] Tried to unmap a page that was not mapped.");
+    }
+  }
+
+  auto recursive_page_mapper::try_unmap(page page) -> bool
+  {
+    auto & root = paging_root::get();
+    if (!root.translate(page))
+    {
+      return false;
+    }
+    root.unmap(page);
+    return true;
+  }
+
+}  // namespace teachos::memory::x86_64
\ No newline at end of file
diff --git a/arch/x86_64/src/memory/scoped_mapping.cpp b/arch/x86_64/src/memory/scoped_mapping.cpp
index 44dbf45..6f3461c 100644
--- a/arch/x86_64/src/memory/scoped_mapping.cpp
+++ b/arch/x86_64/src/memory/scoped_mapping.cpp
@@ -5,10 +5,8 @@
 
 #include "x86_64/memory/mmu.hpp"
 #include "x86_64/memory/page_table.hpp"
-#include "x86_64/memory/page_utilities.hpp"
 #include "x86_64/memory/paging_root.hpp"
 
-#include <memory>
 #include <utility>
 
 namespace teachos::memory::x86_64
@@ -16,16 +14,12 @@ namespace teachos::memory::x86_64
 
   scoped_mapping::scoped_mapping(scoped_mapping && other) noexcept
       : m_page{std::exchange(other.m_page, page{})}
-      , m_allocator{std::exchange(other.m_allocator, nullptr)}
       , m_mapped{std::exchange(other.m_mapped, false)}
-      , m_allocated{std::exchange(other.m_allocated, 0)}
   {}
 
-  scoped_mapping::scoped_mapping(page page, frame_allocator & allocator)
+  scoped_mapping::scoped_mapping(page page)
       : m_page{page}
-      , m_allocator{&allocator}
       , m_mapped{false}
-      , m_allocated{}
   {
     if (paging_root::get().translate(page))
     {
@@ -44,105 +38,28 @@ namespace teachos::memory::x86_64
 
   auto scoped_mapping::operator=(scoped_mapping && other) noexcept -> scoped_mapping &
   {
-    this->swap(other);
+    swap(*this, other);
     return *this;
   }
 
   auto scoped_mapping::map(frame frame, page_table::entry::flags flags) -> std::byte *
   {
-    auto & pml4 = paging_root::get();
-    auto pml4_index = pml_index<4>(m_page);
-    if (!pml4[pml4_index].present())
-    {
-      auto new_frame = m_allocator->allocate();
-      pml4[pml4_index].frame(*new_frame, page_table::entry::flags::present | flags);
-      std::construct_at(pml4.next(pml4_index).value());
-      m_allocated |= 1uz << 2;
-    }
-
-    auto pml3 = pml4.next(pml4_index).value();
-    auto pml3_index = pml_index<3>(m_page);
-    if (!(*pml3)[pml3_index].present())
-    {
-      auto new_frame = m_allocator->allocate();
-      (*pml3)[pml3_index].frame(*new_frame, page_table::entry::flags::present | flags);
-      std::construct_at((*pml3).next(pml3_index).value());
-      m_allocated |= 1uz << 1;
-    }
-
-    auto pml2 = (*pml3).next(pml3_index).value();
-    auto pml2_index = pml_index<2>(m_page);
-    if (!(*pml2)[pml2_index].present())
-    {
-      auto new_frame = m_allocator->allocate();
-      (*pml2)[pml2_index].frame(*new_frame, page_table::entry::flags::present | flags);
-      std::construct_at((*pml2).next(pml2_index).value());
-      m_allocated |= 1uz << 0;
-    }
-
-    auto pml1 = (*pml2).next(pml2_index).value();
-    auto pml1_index = pml_index<1>(m_page);
-    (*pml1)[pml1_index].frame(frame, page_table::entry::flags::present | flags);
-
+    auto result = active_mapper().map(m_page, frame, to_mapper_flags(flags));
     m_mapped = true;
-
-    return static_cast<std::byte *>(m_page.start_address());
+    return result;
   }
 
   auto scoped_mapping::unmap() -> void
   {
-    if (!m_mapped)
-    {
-      system::panic("[MEM] Tried to release an unmapped temporary mapping!");
-    }
-
-    auto pml4 = &paging_root::get();
-    auto pml3 = pml4->next(pml_index<4>(m_page)).value();
-    auto pml2 = pml3->next(pml_index<3>(m_page)).value();
-    auto pml1 = pml2->next(pml_index<2>(m_page)).value();
-
-    (*pml1)[pml_index<1>(m_page)].clear();
-
-    if (m_allocated & 1uz << 0)
-    {
-      auto pml1_frame = (*pml2)[pml_index<2>(m_page)].frame().value();
-      m_allocator->release(pml1_frame);
-      (*pml2)[pml_index<2>(m_page)].clear();
-    }
-
-    if (m_allocated & 1uz << 1)
-    {
-      auto pml2_frame = (*pml3)[pml_index<3>(m_page)].frame().value();
-      m_allocator->release(pml2_frame);
-      (*pml3)[pml_index<3>(m_page)].clear();
-    }
-
-    if (m_allocated & 1uz << 2)
-    {
-      auto pml3_frame = (*pml4)[pml_index<4>(m_page)].frame().value();
-      m_allocator->release(pml3_frame);
-      (*pml4)[pml_index<4>(m_page)].clear();
-    }
-
+    active_mapper().unmap(m_page);
     m_mapped = false;
   }
 
-  auto scoped_mapping::swap(scoped_mapping & other) -> void
-  {
-    using std::swap;
-
-    if (&other == this)
-      return;
-
-    swap(m_page, other.m_page);
-    swap(m_allocator, other.m_allocator);
-    swap(m_mapped, other.m_mapped);
-    swap(m_allocated, other.m_allocated);
-  }
-
   auto swap(scoped_mapping & lhs, scoped_mapping & rhs) -> void
   {
-    lhs.swap(rhs);
+    using std::swap;
+    swap(lhs.m_page, rhs.m_page);
+    swap(lhs.m_mapped, rhs.m_mapped);
   }
 
 }  // namespace teachos::memory::x86_64
\ No newline at end of file