1 files changed, 31 insertions, 27 deletions

diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 47b3ac57b..73b85d6f9 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -14,14 +14,14 @@
 #include "core/device_memory.h"
 #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/memory_block_manager.h"
-#include "core/hle/kernel/memory/page_table.h"
-#include "core/hle/kernel/memory/slab_heap.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/lock.h"
@@ -274,7 +274,7 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
     // Set initial resource limits
     resource_limit->SetLimitValue(
         LimitableResource::PhysicalMemory,
-        kernel.MemoryManager().GetSize(Memory::MemoryManager::Pool::Application));
+        kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application));
     KScopedResourceReservation memory_reservation(resource_limit, LimitableResource::PhysicalMemory,
                                                   code_size + system_resource_size);
     if (!memory_reservation.Succeeded()) {
@@ -285,15 +285,15 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
     // Initialize proces address space
     if (const ResultCode result{
             page_table->InitializeForProcess(metadata.GetAddressSpaceType(), false, 0x8000000,
-                                             code_size, Memory::MemoryManager::Pool::Application)};
+                                             code_size, KMemoryManager::Pool::Application)};
         result.IsError()) {
         return result;
     }
 
     // Map process code region
-    if (const ResultCode result{page_table->MapProcessCode(
-            page_table->GetCodeRegionStart(), code_size / Memory::PageSize,
-            Memory::MemoryState::Code, Memory::MemoryPermission::None)};
+    if (const ResultCode result{page_table->MapProcessCode(page_table->GetCodeRegionStart(),
+                                                           code_size / PageSize, KMemoryState::Code,
+                                                           KMemoryPermission::None)};
         result.IsError()) {
         return result;
     }
@@ -323,6 +323,11 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
         UNREACHABLE();
     }
 
+    // Set initial resource limits
+    resource_limit->SetLimitValue(
+        LimitableResource::PhysicalMemory,
+        kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application));
+
     resource_limit->SetLimitValue(LimitableResource::Threads, 608);
     resource_limit->SetLimitValue(LimitableResource::Events, 700);
     resource_limit->SetLimitValue(LimitableResource::TransferMemory, 128);
@@ -400,22 +405,22 @@ VAddr Process::CreateTLSRegion() {
         return *tls_page_iter->ReserveSlot();
     }
 
-    Memory::Page* const tls_page_ptr{kernel.GetUserSlabHeapPages().Allocate()};
+    Page* const tls_page_ptr{kernel.GetUserSlabHeapPages().Allocate()};
     ASSERT(tls_page_ptr);
 
     const VAddr start{page_table->GetKernelMapRegionStart()};
     const VAddr size{page_table->GetKernelMapRegionEnd() - start};
     const PAddr tls_map_addr{system.DeviceMemory().GetPhysicalAddr(tls_page_ptr)};
-    const VAddr tls_page_addr{
-        page_table
-            ->AllocateAndMapMemory(1, Memory::PageSize, true, start, size / Memory::PageSize,
-                                   Memory::MemoryState::ThreadLocal,
-                                   Memory::MemoryPermission::ReadAndWrite, tls_map_addr)
-            .ValueOr(0)};
+    const VAddr tls_page_addr{page_table
+                                  ->AllocateAndMapMemory(1, PageSize, true, start, size / PageSize,
+                                                         KMemoryState::ThreadLocal,
+                                                         KMemoryPermission::ReadAndWrite,
+                                                         tls_map_addr)
+                                  .ValueOr(0)};
 
     ASSERT(tls_page_addr);
 
-    std::memset(tls_page_ptr, 0, Memory::PageSize);
+    std::memset(tls_page_ptr, 0, PageSize);
     tls_pages.emplace_back(tls_page_addr);
 
     const auto reserve_result{tls_pages.back().ReserveSlot()};
@@ -442,15 +447,15 @@ void Process::FreeTLSRegion(VAddr tls_address) {
 void Process::LoadModule(CodeSet code_set, VAddr base_addr) {
     std::lock_guard lock{HLE::g_hle_lock};
     const auto ReprotectSegment = [&](const CodeSet::Segment& segment,
-                                      Memory::MemoryPermission permission) {
+                                      KMemoryPermission permission) {
         page_table->SetCodeMemoryPermission(segment.addr + base_addr, segment.size, permission);
     };
 
     system.Memory().WriteBlock(*this, base_addr, code_set.memory.data(), code_set.memory.size());
 
-    ReprotectSegment(code_set.CodeSegment(), Memory::MemoryPermission::ReadAndExecute);
-    ReprotectSegment(code_set.RODataSegment(), Memory::MemoryPermission::Read);
-    ReprotectSegment(code_set.DataSegment(), Memory::MemoryPermission::ReadAndWrite);
+    ReprotectSegment(code_set.CodeSegment(), KMemoryPermission::ReadAndExecute);
+    ReprotectSegment(code_set.RODataSegment(), KMemoryPermission::Read);
+    ReprotectSegment(code_set.DataSegment(), KMemoryPermission::ReadAndWrite);
 }
 
 bool Process::IsSignaled() const {
@@ -459,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;
 
@@ -479,16 +484,15 @@ ResultCode Process::AllocateMainThreadStack(std::size_t stack_size) {
     ASSERT(stack_size);
 
     // The kernel always ensures that the given stack size is page aligned.
-    main_thread_stack_size = Common::AlignUp(stack_size, Memory::PageSize);
+    main_thread_stack_size = Common::AlignUp(stack_size, PageSize);
 
     const VAddr start{page_table->GetStackRegionStart()};
     const std::size_t size{page_table->GetStackRegionEnd() - start};
 
     CASCADE_RESULT(main_thread_stack_top,
                    page_table->AllocateAndMapMemory(
-                       main_thread_stack_size / Memory::PageSize, Memory::PageSize, false, start,
-                       size / Memory::PageSize, Memory::MemoryState::Stack,
-                       Memory::MemoryPermission::ReadAndWrite));
+                       main_thread_stack_size / PageSize, PageSize, false, start, size / PageSize,
+                       KMemoryState::Stack, KMemoryPermission::ReadAndWrite));
 
     main_thread_stack_top += main_thread_stack_size;