14 files changed, 118 insertions, 134 deletions

diff --git a/src/core/hle/kernel/k_memory_manager.cpp b/src/core/hle/kernel/k_memory_manager.cpp
index 5ea11a918..9027602bf 100644
--- a/src/core/hle/kernel/k_memory_manager.cpp
+++ b/src/core/hle/kernel/k_memory_manager.cpp
@@ -21,7 +21,7 @@ std::size_t KMemoryManager::Impl::Initialize(Pool new_pool, u64 start_address, u
     const auto ref_count_size{(size / PageSize) * sizeof(u16)};
     const auto optimize_map_size{(Common::AlignUp((size / PageSize), 64) / 64) * sizeof(u64)};
     const auto manager_size{Common::AlignUp(optimize_map_size + ref_count_size, PageSize)};
-    const auto page_heap_size{Memory::PageHeap::CalculateManagementOverheadSize(size)};
+    const auto page_heap_size{KPageHeap::CalculateManagementOverheadSize(size)};
     const auto total_metadata_size{manager_size + page_heap_size};
     ASSERT(manager_size <= total_metadata_size);
     ASSERT(Common::IsAligned(total_metadata_size, PageSize));
@@ -59,7 +59,7 @@ VAddr KMemoryManager::AllocateAndOpenContinuous(std::size_t num_pages, std::size
     std::lock_guard lock{pool_locks[pool_index]};
 
     // Choose a heap based on our page size request
-    const s32 heap_index{Memory::PageHeap::GetAlignedBlockIndex(num_pages, align_pages)};
+    const s32 heap_index{KPageHeap::GetAlignedBlockIndex(num_pages, align_pages)};
 
     // Loop, trying to iterate from each block
     // TODO (bunnei): Support multiple managers
@@ -72,7 +72,7 @@ VAddr KMemoryManager::AllocateAndOpenContinuous(std::size_t num_pages, std::size
     }
 
     // If we allocated more than we need, free some
-    const auto allocated_pages{Memory::PageHeap::GetBlockNumPages(heap_index)};
+    const auto allocated_pages{KPageHeap::GetBlockNumPages(heap_index)};
     if (allocated_pages > num_pages) {
         chosen_manager.Free(allocated_block + num_pages * PageSize, allocated_pages - num_pages);
     }
@@ -94,7 +94,7 @@ ResultCode KMemoryManager::Allocate(KPageLinkedList& page_list, std::size_t num_
     std::lock_guard lock{pool_locks[pool_index]};
 
     // Choose a heap based on our page size request
-    const s32 heap_index{Memory::PageHeap::GetBlockIndex(num_pages)};
+    const s32 heap_index{KPageHeap::GetBlockIndex(num_pages)};
     if (heap_index < 0) {
         return ResultOutOfMemory;
     }
@@ -113,7 +113,7 @@ ResultCode KMemoryManager::Allocate(KPageLinkedList& page_list, std::size_t num_
 
     // Keep allocating until we've allocated all our pages
     for (s32 index{heap_index}; index >= 0 && num_pages > 0; index--) {
-        const auto pages_per_alloc{Memory::PageHeap::GetBlockNumPages(index)};
+        const auto pages_per_alloc{KPageHeap::GetBlockNumPages(index)};
 
         while (num_pages >= pages_per_alloc) {
             // Allocate a block
diff --git a/src/core/hle/kernel/k_memory_manager.h b/src/core/hle/kernel/k_memory_manager.h
index 377f642d8..ae9f683b8 100644
--- a/src/core/hle/kernel/k_memory_manager.h
+++ b/src/core/hle/kernel/k_memory_manager.h
@@ -10,14 +10,12 @@
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "core/hle/kernel/memory/page_heap.h"
+#include "core/hle/kernel/k_page_heap.h"
 #include "core/hle/result.h"
 
 namespace Kernel {
-class KPageLinkedList;
-}
 
-namespace Kernel {
+class KPageLinkedList;
 
 class KMemoryManager final : NonCopyable {
 public:
@@ -84,7 +82,7 @@ private:
         using RefCount = u16;
 
     private:
-        Memory::PageHeap heap;
+        KPageHeap heap;
         Pool pool{};
 
     public:
diff --git a/src/core/hle/kernel/memory/page_heap.cpp b/src/core/hle/kernel/k_page_heap.cpp
index 8fb53a0e8..07e062922 100644
--- a/src/core/hle/kernel/memory/page_heap.cpp
+++ b/src/core/hle/kernel/k_page_heap.cpp
@@ -2,16 +2,13 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
-
 #include "core/core.h"
-#include "core/hle/kernel/memory/page_heap.h"
+#include "core/hle/kernel/k_page_heap.h"
 #include "core/memory.h"
 
-namespace Kernel::Memory {
+namespace Kernel {
 
-void PageHeap::Initialize(VAddr address, std::size_t size, std::size_t metadata_size) {
+void KPageHeap::Initialize(VAddr address, std::size_t size, std::size_t metadata_size) {
     // Check our assumptions
     ASSERT(Common::IsAligned((address), PageSize));
     ASSERT(Common::IsAligned(size, PageSize));
@@ -32,7 +29,7 @@ void PageHeap::Initialize(VAddr address, std::size_t size, std::size_t metadata_
     }
 }
 
-VAddr PageHeap::AllocateBlock(s32 index, bool random) {
+VAddr KPageHeap::AllocateBlock(s32 index, bool random) {
     const std::size_t needed_size{blocks[index].GetSize()};
 
     for (s32 i{index}; i < static_cast<s32>(MemoryBlockPageShifts.size()); i++) {
@@ -48,13 +45,13 @@ VAddr PageHeap::AllocateBlock(s32 index, bool random) {
     return 0;
 }
 
-void PageHeap::FreeBlock(VAddr block, s32 index) {
+void KPageHeap::FreeBlock(VAddr block, s32 index) {
     do {
         block = blocks[index++].PushBlock(block);
     } while (block != 0);
 }
 
-void PageHeap::Free(VAddr addr, std::size_t num_pages) {
+void KPageHeap::Free(VAddr addr, std::size_t num_pages) {
     // Freeing no pages is a no-op
     if (num_pages == 0) {
         return;
@@ -104,16 +101,16 @@ void PageHeap::Free(VAddr addr, std::size_t num_pages) {
     }
 }
 
-std::size_t PageHeap::CalculateManagementOverheadSize(std::size_t region_size) {
+std::size_t KPageHeap::CalculateManagementOverheadSize(std::size_t region_size) {
     std::size_t overhead_size = 0;
     for (std::size_t i = 0; i < MemoryBlockPageShifts.size(); i++) {
         const std::size_t cur_block_shift{MemoryBlockPageShifts[i]};
         const std::size_t next_block_shift{
             (i != MemoryBlockPageShifts.size() - 1) ? MemoryBlockPageShifts[i + 1] : 0};
-        overhead_size += PageHeap::Block::CalculateManagementOverheadSize(
+        overhead_size += KPageHeap::Block::CalculateManagementOverheadSize(
             region_size, cur_block_shift, next_block_shift);
     }
     return Common::AlignUp(overhead_size, PageSize);
 }
 
-} // namespace Kernel::Memory
+} // namespace Kernel
diff --git a/src/core/hle/kernel/memory/page_heap.h b/src/core/hle/kernel/k_page_heap.h
index e21d60a54..de5d6a189 100644
--- a/src/core/hle/kernel/memory/page_heap.h
+++ b/src/core/hle/kernel/k_page_heap.h
@@ -2,9 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosphere, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
-
 #pragma once
 
 #include <array>
@@ -18,9 +15,9 @@
 #include "core/hle/kernel/k_page_bitmap.h"
 #include "core/hle/kernel/memory_types.h"
 
-namespace Kernel::Memory {
+namespace Kernel {
 
-class PageHeap final : NonCopyable {
+class KPageHeap final : NonCopyable {
 public:
     static constexpr s32 GetAlignedBlockIndex(std::size_t num_pages, std::size_t align_pages) {
         const auto target_pages{std::max(num_pages, align_pages)};
@@ -148,7 +145,7 @@ private:
     };
 
 public:
-    PageHeap() = default;
+    KPageHeap() = default;
 
     constexpr VAddr GetAddress() const {
         return heap_address;
@@ -193,4 +190,4 @@ private:
     std::vector<u64> metadata;
 };
 
-} // namespace Kernel::Memory
+} // namespace Kernel
diff --git a/src/core/hle/kernel/memory/page_table.cpp b/src/core/hle/kernel/k_page_table.cpp
index ef9d97413..d09d5ce48 100644
--- a/src/core/hle/kernel/memory/page_table.cpp
+++ b/src/core/hle/kernel/k_page_table.cpp
@@ -10,16 +10,16 @@
 #include "core/hle/kernel/k_memory_block.h"
 #include "core/hle/kernel/k_memory_block_manager.h"
 #include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_system_control.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/memory.h"
 
-namespace Kernel::Memory {
+namespace Kernel {
 
 namespace {
 
@@ -58,11 +58,11 @@ constexpr std::size_t GetSizeInRange(const KMemoryInfo& info, VAddr start, VAddr
 
 } // namespace
 
-PageTable::PageTable(Core::System& system) : system{system} {}
+KPageTable::KPageTable(Core::System& system) : system{system} {}
 
-ResultCode PageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type,
-                                           bool enable_aslr, VAddr code_addr, std::size_t code_size,
-                                           KMemoryManager::Pool pool) {
+ResultCode KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type,
+                                            bool enable_aslr, VAddr code_addr,
+                                            std::size_t code_size, KMemoryManager::Pool pool) {
 
     const auto GetSpaceStart = [this](KAddressSpaceInfo::Type type) {
         return KAddressSpaceInfo::GetAddressSpaceStart(address_space_width, type);
@@ -271,8 +271,8 @@ ResultCode PageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_t
     return InitializeMemoryLayout(start, end);
 }
 
-ResultCode PageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemoryState state,
-                                     KMemoryPermission perm) {
+ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemoryState state,
+                                      KMemoryPermission perm) {
     std::lock_guard lock{page_table_lock};
 
     const u64 size{num_pages * PageSize};
@@ -295,7 +295,7 @@ ResultCode PageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemoryS
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     const std::size_t num_pages{size / PageSize};
@@ -332,7 +332,7 @@ ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     if (!size) {
@@ -363,7 +363,7 @@ ResultCode PageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std
     return RESULT_SUCCESS;
 }
 
-void PageTable::MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start, VAddr end) {
+void KPageTable::MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start, VAddr end) {
     auto node{page_linked_list.Nodes().begin()};
     PAddr map_addr{node->GetAddress()};
     std::size_t src_num_pages{node->GetNumPages()};
@@ -395,7 +395,7 @@ void PageTable::MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start
     });
 }
 
-ResultCode PageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
+ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     std::size_t mapped_size{};
@@ -443,7 +443,7 @@ ResultCode PageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
+ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     const VAddr end_addr{addr + size};
@@ -480,7 +480,7 @@ ResultCode PageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::UnmapMemory(VAddr addr, std::size_t size) {
+ResultCode KPageTable::UnmapMemory(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     const VAddr end_addr{addr + size};
@@ -516,7 +516,7 @@ ResultCode PageTable::UnmapMemory(VAddr addr, std::size_t size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryState src_state{};
@@ -555,7 +555,7 @@ ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryState src_state{};
@@ -597,8 +597,8 @@ ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
-                               KMemoryPermission perm) {
+ResultCode KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
+                                KMemoryPermission perm) {
     VAddr cur_addr{addr};
 
     for (const auto& node : page_linked_list.Nodes()) {
@@ -619,8 +619,8 @@ ResultCode PageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_li
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
-                               KMemoryPermission perm) {
+ResultCode KPageTable::MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
+                                KMemoryPermission perm) {
     std::lock_guard lock{page_table_lock};
 
     const std::size_t num_pages{page_linked_list.GetNumPages()};
@@ -641,8 +641,8 @@ ResultCode PageTable::MapPages(VAddr addr, KPageLinkedList& page_linked_list, KM
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size,
-                                              KMemoryPermission perm) {
+ResultCode KPageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size,
+                                               KMemoryPermission perm) {
 
     std::lock_guard lock{page_table_lock};
 
@@ -689,13 +689,13 @@ ResultCode PageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size,
     return RESULT_SUCCESS;
 }
 
-KMemoryInfo PageTable::QueryInfoImpl(VAddr addr) {
+KMemoryInfo KPageTable::QueryInfoImpl(VAddr addr) {
     std::lock_guard lock{page_table_lock};
 
     return block_manager->FindBlock(addr).GetMemoryInfo();
 }
 
-KMemoryInfo PageTable::QueryInfo(VAddr addr) {
+KMemoryInfo KPageTable::QueryInfo(VAddr addr) {
     if (!Contains(addr, 1)) {
         return {address_space_end,       0 - address_space_end,  KMemoryState::Inaccessible,
                 KMemoryPermission::None, KMemoryAttribute::None, KMemoryPermission::None};
@@ -704,7 +704,7 @@ KMemoryInfo PageTable::QueryInfo(VAddr addr) {
     return QueryInfoImpl(addr);
 }
 
-ResultCode PageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm) {
+ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryState state{};
@@ -722,7 +722,7 @@ ResultCode PageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemor
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
+ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryState state{};
@@ -739,8 +739,8 @@ ResultCode PageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask,
-                                         KMemoryAttribute value) {
+ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask,
+                                          KMemoryAttribute value) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryState state{};
@@ -761,13 +761,13 @@ ResultCode PageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAt
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::SetHeapCapacity(std::size_t new_heap_capacity) {
+ResultCode KPageTable::SetHeapCapacity(std::size_t new_heap_capacity) {
     std::lock_guard lock{page_table_lock};
     heap_capacity = new_heap_capacity;
     return RESULT_SUCCESS;
 }
 
-ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
+ResultVal<VAddr> KPageTable::SetHeapSize(std::size_t size) {
 
     if (size > heap_region_end - heap_region_start) {
         return ResultOutOfMemory;
@@ -818,10 +818,10 @@ ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
     return MakeResult<VAddr>(heap_region_start);
 }
 
-ResultVal<VAddr> PageTable::AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
-                                                 bool is_map_only, VAddr region_start,
-                                                 std::size_t region_num_pages, KMemoryState state,
-                                                 KMemoryPermission perm, PAddr map_addr) {
+ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
+                                                  bool is_map_only, VAddr region_start,
+                                                  std::size_t region_num_pages, KMemoryState state,
+                                                  KMemoryPermission perm, PAddr map_addr) {
     std::lock_guard lock{page_table_lock};
 
     if (!CanContain(region_start, region_num_pages * PageSize, state)) {
@@ -852,7 +852,7 @@ ResultVal<VAddr> PageTable::AllocateAndMapMemory(std::size_t needed_num_pages, s
     return MakeResult<VAddr>(addr);
 }
 
-ResultCode PageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
+ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryPermission perm{};
@@ -875,7 +875,7 @@ ResultCode PageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size) {
+ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     KMemoryPermission perm{};
@@ -898,13 +898,13 @@ ResultCode PageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size)
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::InitializeMemoryLayout(VAddr start, VAddr end) {
+ResultCode KPageTable::InitializeMemoryLayout(VAddr start, VAddr end) {
     block_manager = std::make_unique<KMemoryBlockManager>(start, end);
 
     return RESULT_SUCCESS;
 }
 
-bool PageTable::IsRegionMapped(VAddr address, u64 size) {
+bool KPageTable::IsRegionMapped(VAddr address, u64 size) {
     return CheckMemoryState(address, size, KMemoryState::All, KMemoryState::Free,
                             KMemoryPermission::Mask, KMemoryPermission::None,
                             KMemoryAttribute::Mask, KMemoryAttribute::None,
@@ -912,7 +912,7 @@ bool PageTable::IsRegionMapped(VAddr address, u64 size) {
         .IsError();
 }
 
-bool PageTable::IsRegionContiguous(VAddr addr, u64 size) const {
+bool KPageTable::IsRegionContiguous(VAddr addr, u64 size) const {
     auto start_ptr = system.Memory().GetPointer(addr);
     for (u64 offset{}; offset < size; offset += PageSize) {
         if (start_ptr != system.Memory().GetPointer(addr + offset)) {
@@ -923,8 +923,8 @@ bool PageTable::IsRegionContiguous(VAddr addr, u64 size) const {
     return true;
 }
 
-void PageTable::AddRegionToPages(VAddr start, std::size_t num_pages,
-                                 KPageLinkedList& page_linked_list) {
+void KPageTable::AddRegionToPages(VAddr start, std::size_t num_pages,
+                                  KPageLinkedList& page_linked_list) {
     VAddr addr{start};
     while (addr < start + (num_pages * PageSize)) {
         const PAddr paddr{GetPhysicalAddr(addr)};
@@ -936,8 +936,8 @@ void PageTable::AddRegionToPages(VAddr start, std::size_t num_pages,
     }
 }
 
-VAddr PageTable::AllocateVirtualMemory(VAddr start, std::size_t region_num_pages,
-                                       u64 needed_num_pages, std::size_t align) {
+VAddr KPageTable::AllocateVirtualMemory(VAddr start, std::size_t region_num_pages,
+                                        u64 needed_num_pages, std::size_t align) {
     if (is_aslr_enabled) {
         UNIMPLEMENTED();
     }
@@ -945,8 +945,8 @@ VAddr PageTable::AllocateVirtualMemory(VAddr start, std::size_t region_num_pages
                                        IsKernel() ? 1 : 4);
 }
 
-ResultCode PageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
-                              OperationType operation) {
+ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
+                               OperationType operation) {
     std::lock_guard lock{page_table_lock};
 
     ASSERT(Common::IsAligned(addr, PageSize));
@@ -970,8 +970,8 @@ ResultCode PageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLink
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
-                              OperationType operation, PAddr map_addr) {
+ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
+                               OperationType operation, PAddr map_addr) {
     std::lock_guard lock{page_table_lock};
 
     ASSERT(num_pages > 0);
@@ -997,7 +997,7 @@ ResultCode PageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermissi
     return RESULT_SUCCESS;
 }
 
-constexpr VAddr PageTable::GetRegionAddress(KMemoryState state) const {
+constexpr VAddr KPageTable::GetRegionAddress(KMemoryState state) const {
     switch (state) {
     case KMemoryState::Free:
     case KMemoryState::Kernel:
@@ -1032,7 +1032,7 @@ constexpr VAddr PageTable::GetRegionAddress(KMemoryState state) const {
     }
 }
 
-constexpr std::size_t PageTable::GetRegionSize(KMemoryState state) const {
+constexpr std::size_t KPageTable::GetRegionSize(KMemoryState state) const {
     switch (state) {
     case KMemoryState::Free:
     case KMemoryState::Kernel:
@@ -1067,7 +1067,7 @@ constexpr std::size_t PageTable::GetRegionSize(KMemoryState state) const {
     }
 }
 
-constexpr bool PageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) const {
+constexpr bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) const {
     const VAddr end{addr + size};
     const VAddr last{end - 1};
     const VAddr region_start{GetRegionAddress(state)};
@@ -1109,10 +1109,11 @@ constexpr bool PageTable::CanContain(VAddr addr, std::size_t size, KMemoryState
     }
 }
 
-constexpr ResultCode PageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
-                                                 KMemoryState state, KMemoryPermission perm_mask,
-                                                 KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                                 KMemoryAttribute attr) const {
+constexpr ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
+                                                  KMemoryState state, KMemoryPermission perm_mask,
+                                                  KMemoryPermission perm,
+                                                  KMemoryAttribute attr_mask,
+                                                  KMemoryAttribute attr) const {
     // Validate the states match expectation
     if ((info.state & state_mask) != state) {
         return ResultInvalidCurrentMemory;
@@ -1127,12 +1128,12 @@ constexpr ResultCode PageTable::CheckMemoryState(const KMemoryInfo& info, KMemor
     return RESULT_SUCCESS;
 }
 
-ResultCode PageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                                       KMemoryAttribute* out_attr, VAddr addr, std::size_t size,
-                                       KMemoryState state_mask, KMemoryState state,
-                                       KMemoryPermission perm_mask, KMemoryPermission perm,
-                                       KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                                       KMemoryAttribute ignore_attr) {
+ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
+                                        KMemoryAttribute* out_attr, VAddr addr, std::size_t size,
+                                        KMemoryState state_mask, KMemoryState state,
+                                        KMemoryPermission perm_mask, KMemoryPermission perm,
+                                        KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                                        KMemoryAttribute ignore_attr) {
     std::lock_guard lock{page_table_lock};
 
     // Get information about the first block
@@ -1186,4 +1187,4 @@ ResultCode PageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermissio
     return RESULT_SUCCESS;
 }
 
-} // namespace Kernel::Memory
+} // namespace Kernel
diff --git a/src/core/hle/kernel/memory/page_table.h b/src/core/hle/kernel/k_page_table.h
index a9e850e01..49b824379 100644
--- a/src/core/hle/kernel/memory/page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@@ -19,14 +19,12 @@ class System;
 }
 
 namespace Kernel {
-class KMemoryBlockManager;
-}
 
-namespace Kernel::Memory {
+class KMemoryBlockManager;
 
-class PageTable final : NonCopyable {
+class KPageTable final : NonCopyable {
 public:
-    explicit PageTable(Core::System& system);
+    explicit KPageTable(Core::System& system);
 
     ResultCode InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
                                     VAddr code_addr, std::size_t code_size,
@@ -278,4 +276,4 @@ private:
     Core::System& system;
 };
 
-} // namespace Kernel::Memory
+} // namespace Kernel
diff --git a/src/core/hle/kernel/k_shared_memory.cpp b/src/core/hle/kernel/k_shared_memory.cpp
index aade52764..9b14f42b5 100644
--- a/src/core/hle/kernel/k_shared_memory.cpp
+++ b/src/core/hle/kernel/k_shared_memory.cpp
@@ -4,10 +4,10 @@
 
 #include "common/assert.h"
 #include "core/core.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/memory/page_table.h"
 
 namespace Kernel {
 
@@ -21,8 +21,7 @@ KSharedMemory::~KSharedMemory() {
 std::shared_ptr<KSharedMemory> KSharedMemory::Create(
     KernelCore& kernel, Core::DeviceMemory& device_memory, Process* owner_process,
     KPageLinkedList&& page_list, KMemoryPermission owner_permission,
-    KMemoryPermission user_permission, PAddr physical_address, std::size_t size,
-    std::string name) {
+    KMemoryPermission user_permission, PAddr physical_address, std::size_t size, std::string name) {
 
     const auto resource_limit = kernel.GetSystemResourceLimit();
     KScopedResourceReservation memory_reservation(resource_limit, LimitableResource::PhysicalMemory,
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index e0359eb3c..73b85d6f9 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -15,13 +15,13 @@
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/code_set.h"
 #include "core/hle/kernel/k_memory_block_manager.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_slab_heap.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/lock.h"
@@ -464,9 +464,9 @@ bool Process::IsSignaled() const {
 }
 
 Process::Process(Core::System& system)
-    : KSynchronizationObject{system.Kernel()},
-      page_table{std::make_unique<Memory::PageTable>(system)}, handle_table{system.Kernel()},
-      address_arbiter{system}, condition_var{system}, state_lock{system.Kernel()}, system{system} {}
+    : KSynchronizationObject{system.Kernel()}, page_table{std::make_unique<KPageTable>(system)},
+      handle_table{system.Kernel()}, address_arbiter{system}, condition_var{system},
+      state_lock{system.Kernel()}, system{system} {}
 
 Process::~Process() = default;
 
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index 320b0f347..45eefb90e 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -29,16 +29,13 @@ class ProgramMetadata;
 namespace Kernel {
 
 class KernelCore;
+class KPageTable;
 class KResourceLimit;
 class KThread;
 class TLSPage;
 
 struct CodeSet;
 
-namespace Memory {
-class PageTable;
-}
-
 enum class MemoryRegion : u16 {
     APPLICATION = 1,
     SYSTEM = 2,
@@ -104,12 +101,12 @@ public:
     }
 
     /// Gets a reference to the process' page table.
-    Memory::PageTable& PageTable() {
+    KPageTable& PageTable() {
         return *page_table;
     }
 
     /// Gets const a reference to the process' page table.
-    const Memory::PageTable& PageTable() const {
+    const KPageTable& PageTable() const {
         return *page_table;
     }
 
@@ -385,7 +382,7 @@ private:
     ResultCode AllocateMainThreadStack(std::size_t stack_size);
 
     /// Memory manager for this process
-    std::unique_ptr<Memory::PageTable> page_table;
+    std::unique_ptr<KPageTable> page_table;
 
     /// Current status of the process
     ProcessStatus status{};
diff --git a/src/core/hle/kernel/process_capability.cpp b/src/core/hle/kernel/process_capability.cpp
index 7c567049e..3fc326eab 100644
--- a/src/core/hle/kernel/process_capability.cpp
+++ b/src/core/hle/kernel/process_capability.cpp
@@ -7,7 +7,7 @@
 #include "common/bit_util.h"
 #include "common/logging/log.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/memory/page_table.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/process_capability.h"
 #include "core/hle/kernel/svc_results.h"
 
@@ -69,7 +69,7 @@ u32 GetFlagBitOffset(CapabilityType type) {
 
 ResultCode ProcessCapabilities::InitializeForKernelProcess(const u32* capabilities,
                                                            std::size_t num_capabilities,
-                                                           Memory::PageTable& page_table) {
+                                                           KPageTable& page_table) {
     Clear();
 
     // Allow all cores and priorities.
@@ -82,7 +82,7 @@ ResultCode ProcessCapabilities::InitializeForKernelProcess(const u32* capabiliti
 
 ResultCode ProcessCapabilities::InitializeForUserProcess(const u32* capabilities,
                                                          std::size_t num_capabilities,
-                                                         Memory::PageTable& page_table) {
+                                                         KPageTable& page_table) {
     Clear();
 
     return ParseCapabilities(capabilities, num_capabilities, page_table);
@@ -108,7 +108,7 @@ void ProcessCapabilities::InitializeForMetadatalessProcess() {
 
 ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
                                                   std::size_t num_capabilities,
-                                                  Memory::PageTable& page_table) {
+                                                  KPageTable& page_table) {
     u32 set_flags = 0;
     u32 set_svc_bits = 0;
 
@@ -155,7 +155,7 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
 }
 
 ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits,
-                                                          u32 flag, Memory::PageTable& page_table) {
+                                                          u32 flag, KPageTable& page_table) {
     const auto type = GetCapabilityType(flag);
 
     if (type == CapabilityType::Unset) {
@@ -293,12 +293,12 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)
 }
 
 ResultCode ProcessCapabilities::HandleMapPhysicalFlags(u32 flags, u32 size_flags,
-                                                       Memory::PageTable& page_table) {
+                                                       KPageTable& page_table) {
     // TODO(Lioncache): Implement once the memory manager can handle this.
     return RESULT_SUCCESS;
 }
 
-ResultCode ProcessCapabilities::HandleMapIOFlags(u32 flags, Memory::PageTable& page_table) {
+ResultCode ProcessCapabilities::HandleMapIOFlags(u32 flags, KPageTable& page_table) {
     // TODO(Lioncache): Implement once the memory manager can handle this.
     return RESULT_SUCCESS;
 }
diff --git a/src/core/hle/kernel/process_capability.h b/src/core/hle/kernel/process_capability.h
index ea9d12c16..73ad197fa 100644
--- a/src/core/hle/kernel/process_capability.h
+++ b/src/core/hle/kernel/process_capability.h
@@ -12,9 +12,7 @@ union ResultCode;
 
 namespace Kernel {
 
-namespace Memory {
-class PageTable;
-}
+class KPageTable;
 
 /// The possible types of programs that may be indicated
 /// by the program type capability descriptor.
@@ -90,7 +88,7 @@ public:
     ///          otherwise, an error code upon failure.
     ///
     ResultCode InitializeForKernelProcess(const u32* capabilities, std::size_t num_capabilities,
-                                          Memory::PageTable& page_table);
+                                          KPageTable& page_table);
 
     /// Initializes this process capabilities instance for a userland process.
     ///
@@ -103,7 +101,7 @@ public:
     ///          otherwise, an error code upon failure.
     ///
     ResultCode InitializeForUserProcess(const u32* capabilities, std::size_t num_capabilities,
-                                        Memory::PageTable& page_table);
+                                        KPageTable& page_table);
 
     /// Initializes this process capabilities instance for a process that does not
     /// have any metadata to parse.
@@ -189,7 +187,7 @@ private:
     /// @return RESULT_SUCCESS if no errors occur, otherwise an error code.
     ///
     ResultCode ParseCapabilities(const u32* capabilities, std::size_t num_capabilities,
-                                 Memory::PageTable& page_table);
+                                 KPageTable& page_table);
 
     /// Attempts to parse a capability descriptor that is only represented by a
     /// single flag set.
@@ -204,7 +202,7 @@ private:
     /// @return RESULT_SUCCESS if no errors occurred, otherwise an error code.
     ///
     ResultCode ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits, u32 flag,
-                                         Memory::PageTable& page_table);
+                                         KPageTable& page_table);
 
     /// Clears the internal state of this process capability instance. Necessary,
     /// to have a sane starting point due to us allowing running executables without
@@ -228,10 +226,10 @@ private:
     ResultCode HandleSyscallFlags(u32& set_svc_bits, u32 flags);
 
     /// Handles flags related to mapping physical memory pages.
-    ResultCode HandleMapPhysicalFlags(u32 flags, u32 size_flags, Memory::PageTable& page_table);
+    ResultCode HandleMapPhysicalFlags(u32 flags, u32 size_flags, KPageTable& page_table);
 
     /// Handles flags related to mapping IO pages.
-    ResultCode HandleMapIOFlags(u32 flags, Memory::PageTable& page_table);
+    ResultCode HandleMapIOFlags(u32 flags, KPageTable& page_table);
 
     /// Handles flags related to the interrupt capability flags.
     ResultCode HandleInterruptFlags(u32 flags);
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 4ffd65d33..cc8fa6576 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -29,6 +29,7 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_memory_block.h"
 #include "core/hle/kernel/k_memory_layout.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
@@ -39,7 +40,6 @@
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
@@ -67,8 +67,8 @@ constexpr bool IsValidAddressRange(VAddr address, u64 size) {
 // Helper function that performs the common sanity checks for svcMapMemory
 // and svcUnmapMemory. This is doable, as both functions perform their sanitizing
 // in the same order.
-ResultCode MapUnmapMemorySanityChecks(const Memory::PageTable& manager, VAddr dst_addr,
-                                      VAddr src_addr, u64 size) {
+ResultCode MapUnmapMemorySanityChecks(const KPageTable& manager, VAddr dst_addr, VAddr src_addr,
+                                      u64 size) {
     if (!Common::Is4KBAligned(dst_addr)) {
         LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
         return ResultInvalidAddress;
diff --git a/src/core/hle/kernel/transfer_memory.cpp b/src/core/hle/kernel/transfer_memory.cpp
index b92559616..cad063e4d 100644
--- a/src/core/hle/kernel/transfer_memory.cpp
+++ b/src/core/hle/kernel/transfer_memory.cpp
@@ -2,9 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/transfer_memory.h"
 #include "core/hle/result.h"
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index b42184a3b..d111c1357 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -11,8 +11,8 @@
 #include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_system_control.h"
-#include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/service/ldr/ldr.h"
@@ -287,8 +287,7 @@ public:
         rb.Push(RESULT_SUCCESS);
     }
 
-    bool ValidateRegionForMap(Kernel::Memory::PageTable& page_table, VAddr start,
-                              std::size_t size) const {
+    bool ValidateRegionForMap(Kernel::KPageTable& page_table, VAddr start, std::size_t size) const {
         constexpr std::size_t padding_size{4 * Kernel::PageSize};
         const auto start_info{page_table.QueryInfo(start - 1)};
 
@@ -309,7 +308,7 @@ public:
         return (start + size + padding_size) <= (end_info.GetAddress() + end_info.GetSize());
     }
 
-    VAddr GetRandomMapRegion(const Kernel::Memory::PageTable& page_table, std::size_t size) const {
+    VAddr GetRandomMapRegion(const Kernel::KPageTable& page_table, std::size_t size) const {
         VAddr addr{};
         const std::size_t end_pages{(page_table.GetAliasCodeRegionSize() - size) >>
                                     Kernel::PageBits};