2 files changed, 166 insertions, 0 deletions
diff --git a/arch/x86_64/include/x86_64/memory/page_table.hpp b/arch/x86_64/include/x86_64/memory/page_table.hpp
new file mode 100644
index 0000000..53af5d0
--- /dev/null
+++ b/arch/x86_64/include/x86_64/memory/page_table.hpp
@@ -0,0 +1,139 @@
+#ifndef TEACHOS_X86_64_PAGE_TABLE_HPP
+#define TEACHOS_X86_64_PAGE_TABLE_HPP
+
+#include "kapi/memory.hpp"
+
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <utility>
+
+namespace teachos::memory::x86_64
+{
+
+  //! A table containing paging entries.
+  struct page_table
+  {
+    //! The maximum number of entries in this table.
+    constexpr auto static entry_count{512};
+
+    //! A single page table entry
+    struct entry
+    {
+      //! Flags marking the state and configuration of an entry.
+      enum struct flags : std::uint64_t
+      {
+        empty = 0,
+        present = 1uz << 0,
+        writable = 1uz << 1,
+        user_accessible = 1uz << 2,
+        write_through = 1uz << 3,
+        disable_cache = 1uz << 4,
+        accessed = 1uz << 5,
+        dirty = 1uz << 6,
+        huge_page = 1uz << 7,
+        global = 1uz << 8,
+        no_execute = 1uz << 63,
+      };
+
+      entry() = default;
+
+      //! Clear this entry, ensuring all information is set to zero, marking the page represented by this entry as not
+      //! present.
+      auto clear() -> void;
+
+      //! Check if the page represented by this entry is present at the containing page table's level.
+      [[nodiscard]] auto present() const -> bool;
+
+      //! Check if the page represented by this entry is huge (2MiB, or 1GiB, depending on the containing page table's
+      //! level).
+      [[nodiscard]] auto huge() const -> bool;
+
+      //! Get all flags present in this entry.
+      [[nodiscard]] auto all_flags() const -> flags;
+
+      //! Get the frame number associated with this entry, if the referenced page is present.
+      [[nodiscard]] auto frame() const -> std::optional<frame>;
+
+      //! Set the entry to reference the given frame with the given flags.
+      auto frame(struct frame frame, flags flags) -> void;
+
+    private:
+      //! A mask to retrieve, or exclude, the frame number from the raw entry.
+      constexpr auto static frame_number_mask{0x000f'ffff'ffff'f000uz};
+
+      std::uint64_t m_raw{};
+    };
+
+    //! Get the entry at the given index.
+    [[nodiscard]] auto operator[](std::size_t index) -> entry &;
+    [[nodiscard]] auto operator[](std::size_t index) const -> entry const &;
+
+    //! Clear the entire page table, effectively evicting all entries.
+    auto clear() -> void;
+
+  private:
+    std::array<entry, entry_count> m_entries{};
+  };
+
+  constexpr auto operator|(page_table::entry::flags lhs, page_table::entry::flags rhs) -> page_table::entry::flags
+  {
+    return std::bit_cast<page_table::entry::flags>(std::to_underlying(lhs) | std::to_underlying(rhs));
+  }
+
+  constexpr auto operator&(page_table::entry::flags lhs, page_table::entry::flags rhs) -> page_table::entry::flags
+  {
+    return std::bit_cast<page_table::entry::flags>(std::to_underlying(lhs) & std::to_underlying(rhs));
+  }
+
+  //! A recursively mapped page table.
+  template<std::size_t Level>
+    requires(Level > 0uz && Level < 5uz)
+  struct recursive_page_table : page_table
+  {
+    constexpr auto static next_level = Level - 1uz;
+    constexpr auto static recursive_index = 0776uz;
+
+    //! Get the next lower lever table.
+    [[nodiscard]] auto next(this auto && self, std::size_t index)
+      requires(next_level > 1)
+    {
+      return self.next_address(index).transform([](auto address) -> auto {
+        auto table_pointer = std::bit_cast<recursive_page_table<next_level> *>(address);
+        return &std::forward_like<decltype(self)>(*table_pointer);
+      });
+    }
+
+    //! Get the next lower lever table.
+    [[nodiscard]] auto next(this auto && self, std::size_t index)
+      requires(next_level == 1)
+    {
+      return self.next_address(index).transform([](auto address) -> auto {
+        auto table_pointer = std::bit_cast<page_table *>(address);
+        return &std::forward_like<decltype(self)>(*table_pointer);
+      });
+    }
+
+  private:
+    constexpr auto static level_bits = 9;
+    constexpr auto static high_bit = 48;
+    constexpr auto static offset_bits = 12;
+
+    [[nodiscard]] auto next_address(std::size_t index) const -> std::optional<std::uintptr_t>
+    {
+      if (auto entry = (*this)[index]; entry.present() && !entry.huge())
+      {
+        auto this_address = std::bit_cast<std::uintptr_t>(this);
+        auto next_address = (this_address << level_bits) | 1uz << high_bit | (index << offset_bits);
+        return next_address;
+      }
+
+      return std::nullopt;
+    }
+  };
+
+}  // namespace teachos::memory::x86_64
+
+#endif
+\ No newline at end of file
diff --git a/arch/x86_64/include/x86_64/memory/paging_root.hpp b/arch/x86_64/include/x86_64/memory/paging_root.hpp
new file mode 100644
index 0000000..365e180
--- /dev/null
+++ b/arch/x86_64/include/x86_64/memory/paging_root.hpp
@@ -0,0 +1,27 @@
+#ifndef TEACHOS_X86_64_PAGING_ROOT_HPP
+#define TEACHOS_X86_64_PAGING_ROOT_HPP
+
+#include "kapi/memory.hpp"
+
+#include "x86_64/memory/page_table.hpp"
+
+#include <optional>
+
+namespace teachos::memory::x86_64
+{
+
+  //! The active, recursively mapped, root map (e.g. PML4)
+  struct paging_root : recursive_page_table<4>
+  {
+    auto static get() -> paging_root &;
+
+    [[nodiscard]] auto translate(linear_address address) const -> std::optional<physical_address>;
+    [[nodiscard]] auto translate(page page) const -> std::optional<frame>;
+
+  private:
+    paging_root() = default;
+  };
+
+}  // namespace teachos::memory::x86_64
+
+#endif
+\ No newline at end of file