chore: restructure namespaces

7 files changed, 75 insertions, 73 deletions

diff --git a/arch/x86_64/src/memory/kernel_mapper.cpp b/arch/x86_64/src/memory/kernel_mapper.cpp
index 89b2e83..08c32c5 100644
--- a/arch/x86_64/src/memory/kernel_mapper.cpp
+++ b/arch/x86_64/src/memory/kernel_mapper.cpp
@@ -1,9 +1,9 @@
-#include "x86_64/memory/kernel_mapper.hpp"
+#include "arch/memory/kernel_mapper.hpp"
 
 #include "kapi/memory.hpp"
 #include "kapi/system.hpp"
 
-#include "x86_64/boot/ld.hpp"
+#include "arch/boot/ld.hpp"
 
 #include <kstd/print>
 
@@ -19,7 +19,7 @@
 #include <string_view>
 #include <utility>
 
-namespace teachos::memory::x86_64
+namespace arch::memory
 {
 
   namespace
@@ -39,15 +39,15 @@ namespace teachos::memory::x86_64
 
   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)}
+      , m_kernel_load_base{std::bit_cast<std::uintptr_t>(&arch::boot::TEACHOS_VMA)}
   {}
 
-  auto kernel_mapper::remap_kernel(page_mapper & mapper) -> void
+  auto kernel_mapper::remap_kernel(kapi::memory::page_mapper & mapper) -> void
   {
     auto elf_information = m_mbi->maybe_elf_symbols<elf::format::elf64>();
     if (!elf_information)
     {
-      system::panic("[x86_64:MEM] ELF section information is not available.");
+      kapi::system::panic("[x86_64:MEM] ELF section information is not available.");
     }
 
     auto sections = *elf_information;
@@ -61,38 +61,38 @@ namespace teachos::memory::x86_64
 
     if (allocated_sections.empty())
     {
-      system::panic("[x86_64:MEM] No allocated ELF sections were found.");
+      kapi::system::panic("[x86_64:MEM] No allocated ELF sections were found.");
     }
 
     std::ranges::for_each(allocated_sections,
                           [&](auto const & section) -> auto { map_section(section, sections.name(section), mapper); });
   }
 
-  auto kernel_mapper::map_section(section_header_type const & section, std::string_view name, page_mapper & mapper)
-      -> void
+  auto kernel_mapper::map_section(section_header_type const & section, std::string_view name,
+                                  kapi::memory::page_mapper & mapper) -> void
   {
     auto number_of_pages = (section.size + (PLATFORM_PAGE_SIZE - 1)) / PLATFORM_PAGE_SIZE;
-    auto linear_start_address = linear_address{section.virtual_load_address};
-    auto physical_start_address = physical_address{section.virtual_load_address & ~m_kernel_load_base};
+    auto linear_start_address = kapi::memory::linear_address{section.virtual_load_address};
+    auto physical_start_address = kapi::memory::physical_address{section.virtual_load_address & ~m_kernel_load_base};
 
     kstd::println("[x86_64:MEM] mapping {}"
                   "\n  {} bytes -> page count: {}"
                   "\n  {} @ {}",
                   name, section.size, number_of_pages, linear_start_address, physical_start_address);
 
-    auto first_page = page::containing(linear_start_address);
-    auto first_frame = frame::containing(physical_start_address);
+    auto first_page = kapi::memory::page::containing(linear_start_address);
+    auto first_frame = kapi::memory::frame::containing(physical_start_address);
 
-    auto page_flags = page_mapper::flags::empty;
+    auto page_flags = kapi::memory::page_mapper::flags::empty;
 
     if (section.writable())
     {
-      page_flags |= page_mapper::flags::writable;
+      page_flags |= kapi::memory::page_mapper::flags::writable;
     }
 
     if (section.executable())
     {
-      page_flags |= page_mapper::flags::executable;
+      page_flags |= kapi::memory::page_mapper::flags::executable;
     }
 
     auto is_prefix_of_name = [=](auto prefix) -> bool {
@@ -101,7 +101,7 @@ namespace teachos::memory::x86_64
 
     if (!std::ranges::any_of(user_accessible_prefixes, is_prefix_of_name))
     {
-      page_flags |= page_mapper::flags::supervisor_only;
+      page_flags |= kapi::memory::page_mapper::flags::supervisor_only;
     }
 
     for (auto i = 0uz; i < number_of_pages; ++i)
@@ -110,4 +110,4 @@ namespace teachos::memory::x86_64
     }
   }
 
-}  // namespace teachos::memory::x86_64
\ No newline at end of file
+}  // namespace arch::memory
\ No newline at end of file
diff --git a/arch/x86_64/src/memory/mmu.cpp b/arch/x86_64/src/memory/mmu.cpp
index e15d94e..ea23278 100644
--- a/arch/x86_64/src/memory/mmu.cpp
+++ b/arch/x86_64/src/memory/mmu.cpp
@@ -1,14 +1,12 @@
-#include "x86_64/memory/mmu.hpp"
+#include "arch/memory/mmu.hpp"
 
 #include "kapi/memory.hpp"
 
-#include "x86_64/cpu/registers.hpp"
+#include "arch/cpu/registers.hpp"
 
-namespace teachos::memory::x86_64
+namespace arch::memory
 {
-  namespace cpu = cpu::x86_64;
-
-  auto tlb_flush(linear_address address) -> void
+  auto tlb_flush(kapi::memory::linear_address address) -> void
   {
     asm volatile("invlpg (%[input])" : /* no output from call */ : [input] "r"(address) : "memory");
   }
@@ -18,4 +16,4 @@ namespace teachos::memory::x86_64
     auto paging_root = cpu::cr3::read();
     cpu::cr3::write(paging_root);
   }
-}  // namespace teachos::memory::x86_64
+}  // namespace arch::memory
diff --git a/arch/x86_64/src/memory/page_table.cpp b/arch/x86_64/src/memory/page_table.cpp
index 2de099d..26cdd29 100644
--- a/arch/x86_64/src/memory/page_table.cpp
+++ b/arch/x86_64/src/memory/page_table.cpp
@@ -1,4 +1,4 @@
-#include "x86_64/memory/page_table.hpp"
+#include "arch/memory/page_table.hpp"
 
 #include "kapi/memory.hpp"
 
@@ -9,7 +9,7 @@
 #include <optional>
 #include <utility>
 
-namespace teachos::memory::x86_64
+namespace arch::memory
 {
 
   auto page_table::entry::clear() noexcept -> void
@@ -44,16 +44,16 @@ namespace teachos::memory::x86_64
     return *this;
   }
 
-  auto page_table::entry::frame() const noexcept -> std::optional<struct frame>
+  auto page_table::entry::frame() const noexcept -> std::optional<kapi::memory::frame>
   {
     if (present())
     {
-      return frame::containing(physical_address{m_raw & frame_number_mask});
+      return kapi::memory::frame::containing(kapi::memory::physical_address{m_raw & frame_number_mask});
     }
     return std::nullopt;
   }
 
-  auto page_table::entry::frame(struct frame frame, flags flags) noexcept -> void
+  auto page_table::entry::frame(kapi::memory::frame frame, flags flags) noexcept -> void
   {
     m_raw = (frame.start_address().raw() | static_cast<std::uint64_t>(flags));
   };
@@ -79,4 +79,4 @@ namespace teachos::memory::x86_64
                                [](auto const & entry) -> auto { return entry.all_flags() == entry::flags::empty; });
   }
 
-}  // namespace teachos::memory::x86_64
+}  // namespace arch::memory
diff --git a/arch/x86_64/src/memory/paging_root.cpp b/arch/x86_64/src/memory/paging_root.cpp
index d849a82..41f40ed 100644
--- a/arch/x86_64/src/memory/paging_root.cpp
+++ b/arch/x86_64/src/memory/paging_root.cpp
@@ -1,9 +1,9 @@
-#include "x86_64/memory/paging_root.hpp"
+#include "arch/memory/paging_root.hpp"
 
 #include <bit>
 #include <cstdint>
 
-namespace teachos::memory::x86_64
+namespace arch::memory
 {
 
   namespace
@@ -16,4 +16,4 @@ namespace teachos::memory::x86_64
     return std::bit_cast<paging_root *>(recursive_base);
   }
 
-}  // namespace teachos::memory::x86_64
\ No newline at end of file
+}  // namespace arch::memory
\ 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
index c5aabcb..d8273e1 100644
--- a/arch/x86_64/src/memory/recursive_page_mapper.cpp
+++ b/arch/x86_64/src/memory/recursive_page_mapper.cpp
@@ -1,16 +1,16 @@
-#include "x86_64/memory/recursive_page_mapper.hpp"
+#include "arch/memory/recursive_page_mapper.hpp"
 
 #include "kapi/memory.hpp"
 #include "kapi/system.hpp"
 
-#include "x86_64/memory/page_table.hpp"
-#include "x86_64/memory/page_utilities.hpp"
-#include "x86_64/memory/paging_root.hpp"
+#include "arch/memory/page_table.hpp"
+#include "arch/memory/page_utilities.hpp"
+#include "arch/memory/paging_root.hpp"
 
 #include <cstddef>
 #include <optional>
 
-namespace teachos::memory::x86_64
+namespace arch::memory
 {
   namespace
   {
@@ -22,7 +22,8 @@ namespace teachos::memory::x86_64
     //! added, thus still enforcing non-writability and non-execution of the affected page.
     template<std::size_t Level>
       requires(Level > 1uz && Level <= PLATFORM_PAGING_LEVELS)
-    auto do_map(recursive_page_table<Level> * pml, page page, frame_allocator & allocator, page_mapper::flags flags)
+    auto do_map(recursive_page_table<Level> * pml, kapi::memory::page page, kapi::memory::frame_allocator & allocator,
+                kapi::memory::page_mapper::flags flags)
     {
       auto index = pml_index<Level>(page);
       auto entry_flags = to_table_flags(flags);
@@ -41,12 +42,13 @@ namespace teachos::memory::x86_64
     }
 
     //! Perform the actual PML1 update.
-    auto do_map(page_table * pml, page page, frame frame, page_mapper::flags flags) -> std::optional<std::byte *>
+    auto do_map(page_table * pml, kapi::memory::page page, kapi::memory::frame frame,
+                kapi::memory::page_mapper::flags flags) -> std::optional<std::byte *>
     {
       auto index = pml_index<1>(page);
       if ((*pml)[index].present())
       {
-        system::panic("[x86_64:MEM] Tried to map a page that is already mapped");
+        kapi::system::panic("[x86_64:MEM] Tried to map a page that is already mapped");
       }
       (*pml)[index].frame(frame, page_table::entry::flags::present | to_table_flags(flags));
       return std::optional{static_cast<std::byte *>(page.start_address())};
@@ -54,11 +56,11 @@ namespace teachos::memory::x86_64
 
   }  // namespace
 
-  recursive_page_mapper::recursive_page_mapper(frame_allocator & allocator)
+  recursive_page_mapper::recursive_page_mapper(kapi::memory::frame_allocator & allocator)
       : m_allocator{&allocator}
   {}
 
-  auto recursive_page_mapper::map(page page, frame frame, flags flags) -> std::byte *
+  auto recursive_page_mapper::map(kapi::memory::page page, kapi::memory::frame frame, flags flags) -> std::byte *
   {
     auto pml4 = static_cast<recursive_page_table<4> *>((paging_root::get()));
 
@@ -70,15 +72,15 @@ namespace teachos::memory::x86_64
         .value_or(nullptr);
   }
 
-  auto recursive_page_mapper::unmap(page page) -> void
+  auto recursive_page_mapper::unmap(kapi::memory::page page) -> void
   {
     if (!try_unmap(page))
     {
-      system::panic("[x86_64:MEM] Tried to unmap a page that was not mapped.");
+      kapi::system::panic("[x86_64:MEM] Tried to unmap a page that was not mapped.");
     }
   }
 
-  auto recursive_page_mapper::try_unmap(page page) noexcept -> bool
+  auto recursive_page_mapper::try_unmap(kapi::memory::page page) noexcept -> bool
   {
     if (!paging_root::get()->translate(page))
     {
@@ -116,4 +118,4 @@ namespace teachos::memory::x86_64
     return true;
   }
 
-}  // namespace teachos::memory::x86_64
\ No newline at end of file
+}  // namespace arch::memory
\ No newline at end of file
diff --git a/arch/x86_64/src/memory/region_allocator.cpp b/arch/x86_64/src/memory/region_allocator.cpp
index 7a8fb8b..a2dfd48 100644
--- a/arch/x86_64/src/memory/region_allocator.cpp
+++ b/arch/x86_64/src/memory/region_allocator.cpp
@@ -1,4 +1,4 @@
-#include "x86_64/memory/region_allocator.hpp"
+#include "arch/memory/region_allocator.hpp"
 
 #include "kapi/memory/address.hpp"
 #include "kapi/memory/frame.hpp"
@@ -11,16 +11,17 @@
 #include <ranges>
 #include <utility>
 
-namespace teachos::memory::x86_64
+namespace arch::memory
 {
   namespace
   {
     constexpr auto last_frame(multiboot2::memory_map::region const & region)
     {
-      return frame::containing(physical_address{region.base + region.size_in_B - 1});
+      return kapi::memory::frame::containing(kapi::memory::physical_address{region.base + region.size_in_B - 1});
     }
 
-    constexpr auto falls_within(frame const & candidate, frame const & start, frame const & end)
+    constexpr auto falls_within(kapi::memory::frame const & candidate, kapi::memory::frame const & start,
+                                kapi::memory::frame const & end)
     {
       return candidate >= start && candidate <= end;
     }
@@ -30,10 +31,10 @@ namespace teachos::memory::x86_64
       : m_next_frame{}
       , m_current_region{}
       , m_memory_map{mem_info.memory_map}
-      , m_kernel_start(frame::containing(mem_info.image_range.first))
-      , m_kernel_end(frame::containing(mem_info.image_range.second))
-      , m_multiboot_start(frame::containing(mem_info.mbi_range.first))
-      , m_multiboot_end(frame::containing(mem_info.mbi_range.second))
+      , m_kernel_start{kapi::memory::frame::containing(mem_info.image_range.first)}
+      , m_kernel_end{kapi::memory::frame::containing(mem_info.image_range.second)}
+      , m_multiboot_start{kapi::memory::frame::containing(mem_info.mbi_range.first)}
+      , m_multiboot_end{kapi::memory::frame::containing(mem_info.mbi_range.second)}
   {
     choose_next_region();
   }
@@ -56,14 +57,14 @@ namespace teachos::memory::x86_64
     }
 
     m_current_region = *lowest_region;
-    if (auto start_of_region = frame::containing(physical_address{m_current_region->base});
+    if (auto start_of_region = kapi::memory::frame::containing(kapi::memory::physical_address{m_current_region->base});
         start_of_region > m_next_frame)
     {
       m_next_frame = start_of_region;
     }
   }
 
-  auto region_allocator::find_next_frame() -> std::optional<frame>
+  auto region_allocator::find_next_frame() -> std::optional<kapi::memory::frame>
   {
     if (!m_current_region || m_next_frame > last_frame(*m_current_region))
     {
@@ -97,7 +98,8 @@ namespace teachos::memory::x86_64
     return m_current_region.transform([this](auto) -> auto { return m_next_frame; });
   }
 
-  auto region_allocator::allocate_many(std::size_t count) noexcept -> std::optional<std::pair<frame, std::size_t>>
+  auto region_allocator::allocate_many(std::size_t count) noexcept
+      -> std::optional<std::pair<kapi::memory::frame, std::size_t>>
   {
     while (m_current_region)
     {
@@ -122,11 +124,11 @@ namespace teachos::memory::x86_64
     return std::nullopt;
   }
 
-  auto region_allocator::release_many(std::pair<frame, std::size_t>) -> void {}
+  auto region_allocator::release_many(std::pair<kapi::memory::frame, std::size_t>) -> void {}
 
-  auto region_allocator::next_free_frame() noexcept -> std::optional<frame>
+  auto region_allocator::next_free_frame() noexcept -> std::optional<kapi::memory::frame>
   {
     return find_next_frame();
   }
 
-}  // namespace teachos::memory::x86_64
+}  // namespace arch::memory
diff --git a/arch/x86_64/src/memory/scoped_mapping.cpp b/arch/x86_64/src/memory/scoped_mapping.cpp
index 945183d..dde1dda 100644
--- a/arch/x86_64/src/memory/scoped_mapping.cpp
+++ b/arch/x86_64/src/memory/scoped_mapping.cpp
@@ -1,32 +1,32 @@
-#include "x86_64/memory/scoped_mapping.hpp"
+#include "arch/memory/scoped_mapping.hpp"
 
 #include "kapi/memory.hpp"
 #include "kapi/system.hpp"
 
-#include "x86_64/memory/mmu.hpp"
-#include "x86_64/memory/page_table.hpp"
-#include "x86_64/memory/paging_root.hpp"
+#include "arch/memory/mmu.hpp"
+#include "arch/memory/page_table.hpp"
+#include "arch/memory/paging_root.hpp"
 
 #include <cstddef>
 #include <utility>
 
-namespace teachos::memory::x86_64
+namespace arch::memory
 {
 
   scoped_mapping::scoped_mapping(scoped_mapping && other) noexcept
-      : m_page{std::exchange(other.m_page, page{})}
+      : m_page{std::exchange(other.m_page, kapi::memory::page{})}
       , m_mapper{std::exchange(other.m_mapper, nullptr)}
       , m_mapped{std::exchange(other.m_mapped, false)}
   {}
 
-  scoped_mapping::scoped_mapping(page page, page_mapper & mapper)
+  scoped_mapping::scoped_mapping(kapi::memory::page page, kapi::memory::page_mapper & mapper)
       : m_page{page}
       , m_mapper{&mapper}
       , m_mapped{false}
   {
     if (paging_root::get()->translate(page))
     {
-      system::panic("[MEM] Tried to map a page that is already mapped!");
+      kapi::system::panic("[MEM] Tried to map a page that is already mapped!");
     }
   }
 
@@ -35,7 +35,7 @@ namespace teachos::memory::x86_64
     if (m_mapped)
     {
       unmap();
-      x86_64::tlb_flush(m_page.start_address());
+      tlb_flush(m_page.start_address());
     }
   }
 
@@ -45,7 +45,7 @@ namespace teachos::memory::x86_64
     return *this;
   }
 
-  auto scoped_mapping::map(frame frame, page_table::entry::flags flags) -> std::byte *
+  auto scoped_mapping::map(kapi::memory::frame frame, page_table::entry::flags flags) -> std::byte *
   {
     auto result = m_mapper->map(m_page, frame, to_mapper_flags(flags));
     m_mapped = true;
@@ -66,4 +66,4 @@ namespace teachos::memory::x86_64
     swap(lhs.m_mapped, rhs.m_mapped);
   }
 
-}  // namespace teachos::memory::x86_64
\ No newline at end of file
+}  // namespace arch::memory
\ No newline at end of file