1 files changed, 49 insertions, 50 deletions
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 39c5182c5..780008b08 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -27,17 +27,17 @@
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/k_memory_layout.h"
+#include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_shared_memory.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_layout.h"
-#include "core/hle/kernel/memory/memory_manager.h"
-#include "core/hle/kernel/memory/slab_heap.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/service_thread.h"
-#include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/time_manager.h"
 #include "core/hle/lock.h"
@@ -181,9 +181,9 @@ struct KernelCore::Impl {
             std::string name = "Suspend Thread Id:" + std::to_string(i);
             std::function<void(void*)> init_func = Core::CpuManager::GetSuspendThreadStartFunc();
             void* init_func_parameter = system.GetCpuManager().GetStartFuncParamater();
-            auto thread_res = KThread::Create(system, ThreadType::HighPriority, std::move(name), 0,
-                                              0, 0, static_cast<u32>(i), 0, nullptr,
-                                              std::move(init_func), init_func_parameter);
+            auto thread_res = KThread::CreateThread(
+                system, ThreadType::HighPriority, std::move(name), 0, 0, 0, static_cast<u32>(i), 0,
+                nullptr, std::move(init_func), init_func_parameter);
 
             suspend_threads[i] = std::move(thread_res).Unwrap();
         }
@@ -221,10 +221,9 @@ struct KernelCore::Impl {
     // Gets the dummy KThread for the caller, allocating a new one if this is the first time
     KThread* GetHostDummyThread() {
         const thread_local auto thread =
-            KThread::Create(
+            KThread::CreateThread(
                 system, ThreadType::Main, fmt::format("DummyThread:{}", GetHostThreadId()), 0,
-                KThread::DefaultThreadPriority, 0, static_cast<u32>(3), 0, nullptr,
-                []([[maybe_unused]] void* arg) { UNREACHABLE(); }, nullptr)
+                KThread::DefaultThreadPriority, 0, static_cast<u32>(3), 0, nullptr)
                 .Unwrap();
         return thread.get();
     }
@@ -271,7 +270,7 @@ struct KernelCore::Impl {
 
     void InitializeMemoryLayout() {
         // Initialize memory layout
-        constexpr Memory::MemoryLayout layout{Memory::MemoryLayout::GetDefaultLayout()};
+        constexpr KMemoryLayout layout{KMemoryLayout::GetDefaultLayout()};
         constexpr std::size_t hid_size{0x40000};
         constexpr std::size_t font_size{0x1100000};
         constexpr std::size_t irs_size{0x8000};
@@ -282,36 +281,36 @@ struct KernelCore::Impl {
         constexpr PAddr time_addr{layout.System().StartAddress() + hid_size + font_size + irs_size};
 
         // Initialize memory manager
-        memory_manager = std::make_unique<Memory::MemoryManager>();
-        memory_manager->InitializeManager(Memory::MemoryManager::Pool::Application,
+        memory_manager = std::make_unique<KMemoryManager>();
+        memory_manager->InitializeManager(KMemoryManager::Pool::Application,
                                           layout.Application().StartAddress(),
                                           layout.Application().EndAddress());
-        memory_manager->InitializeManager(Memory::MemoryManager::Pool::Applet,
+        memory_manager->InitializeManager(KMemoryManager::Pool::Applet,
                                           layout.Applet().StartAddress(),
                                           layout.Applet().EndAddress());
-        memory_manager->InitializeManager(Memory::MemoryManager::Pool::System,
+        memory_manager->InitializeManager(KMemoryManager::Pool::System,
                                           layout.System().StartAddress(),
                                           layout.System().EndAddress());
 
-        hid_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {hid_addr, hid_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, hid_addr, hid_size, "HID:SharedMemory");
-        font_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {font_pa, font_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, font_pa, font_size, "Font:SharedMemory");
-        irs_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {irs_addr, irs_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, irs_addr, irs_size, "IRS:SharedMemory");
-        time_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {time_addr, time_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, time_addr, time_size, "Time:SharedMemory");
+        hid_shared_mem = Kernel::KSharedMemory::Create(
+            system.Kernel(), system.DeviceMemory(), nullptr, {hid_addr, hid_size / PageSize},
+            KMemoryPermission::None, KMemoryPermission::Read, hid_addr, hid_size,
+            "HID:SharedMemory");
+        font_shared_mem = Kernel::KSharedMemory::Create(
+            system.Kernel(), system.DeviceMemory(), nullptr, {font_pa, font_size / PageSize},
+            KMemoryPermission::None, KMemoryPermission::Read, font_pa, font_size,
+            "Font:SharedMemory");
+        irs_shared_mem = Kernel::KSharedMemory::Create(
+            system.Kernel(), system.DeviceMemory(), nullptr, {irs_addr, irs_size / PageSize},
+            KMemoryPermission::None, KMemoryPermission::Read, irs_addr, irs_size,
+            "IRS:SharedMemory");
+        time_shared_mem = Kernel::KSharedMemory::Create(
+            system.Kernel(), system.DeviceMemory(), nullptr, {time_addr, time_size / PageSize},
+            KMemoryPermission::None, KMemoryPermission::Read, time_addr, time_size,
+            "Time:SharedMemory");
 
         // Allocate slab heaps
-        user_slab_heap_pages = std::make_unique<Memory::SlabHeap<Memory::Page>>();
+        user_slab_heap_pages = std::make_unique<KSlabHeap<Page>>();
 
         constexpr u64 user_slab_heap_size{0x1ef000};
         // Reserve slab heaps
@@ -353,14 +352,14 @@ struct KernelCore::Impl {
     std::atomic<u32> next_host_thread_id{Core::Hardware::NUM_CPU_CORES};
 
     // Kernel memory management
-    std::unique_ptr<Memory::MemoryManager> memory_manager;
-    std::unique_ptr<Memory::SlabHeap<Memory::Page>> user_slab_heap_pages;
+    std::unique_ptr<KMemoryManager> memory_manager;
+    std::unique_ptr<KSlabHeap<Page>> user_slab_heap_pages;
 
     // Shared memory for services
-    std::shared_ptr<Kernel::SharedMemory> hid_shared_mem;
-    std::shared_ptr<Kernel::SharedMemory> font_shared_mem;
-    std::shared_ptr<Kernel::SharedMemory> irs_shared_mem;
-    std::shared_ptr<Kernel::SharedMemory> time_shared_mem;
+    std::shared_ptr<Kernel::KSharedMemory> hid_shared_mem;
+    std::shared_ptr<Kernel::KSharedMemory> font_shared_mem;
+    std::shared_ptr<Kernel::KSharedMemory> irs_shared_mem;
+    std::shared_ptr<Kernel::KSharedMemory> time_shared_mem;
 
     // Threads used for services
     std::unordered_set<std::shared_ptr<Kernel::ServiceThread>> service_threads;
@@ -578,51 +577,51 @@ KThread* KernelCore::GetCurrentEmuThread() const {
     return impl->GetCurrentEmuThread();
 }
 
-Memory::MemoryManager& KernelCore::MemoryManager() {
+KMemoryManager& KernelCore::MemoryManager() {
     return *impl->memory_manager;
 }
 
-const Memory::MemoryManager& KernelCore::MemoryManager() const {
+const KMemoryManager& KernelCore::MemoryManager() const {
     return *impl->memory_manager;
 }
 
-Memory::SlabHeap<Memory::Page>& KernelCore::GetUserSlabHeapPages() {
+KSlabHeap<Page>& KernelCore::GetUserSlabHeapPages() {
     return *impl->user_slab_heap_pages;
 }
 
-const Memory::SlabHeap<Memory::Page>& KernelCore::GetUserSlabHeapPages() const {
+const KSlabHeap<Page>& KernelCore::GetUserSlabHeapPages() const {
     return *impl->user_slab_heap_pages;
 }
 
-Kernel::SharedMemory& KernelCore::GetHidSharedMem() {
+Kernel::KSharedMemory& KernelCore::GetHidSharedMem() {
     return *impl->hid_shared_mem;
 }
 
-const Kernel::SharedMemory& KernelCore::GetHidSharedMem() const {
+const Kernel::KSharedMemory& KernelCore::GetHidSharedMem() const {
     return *impl->hid_shared_mem;
 }
 
-Kernel::SharedMemory& KernelCore::GetFontSharedMem() {
+Kernel::KSharedMemory& KernelCore::GetFontSharedMem() {
     return *impl->font_shared_mem;
 }
 
-const Kernel::SharedMemory& KernelCore::GetFontSharedMem() const {
+const Kernel::KSharedMemory& KernelCore::GetFontSharedMem() const {
     return *impl->font_shared_mem;
 }
 
-Kernel::SharedMemory& KernelCore::GetIrsSharedMem() {
+Kernel::KSharedMemory& KernelCore::GetIrsSharedMem() {
     return *impl->irs_shared_mem;
 }
 
-const Kernel::SharedMemory& KernelCore::GetIrsSharedMem() const {
+const Kernel::KSharedMemory& KernelCore::GetIrsSharedMem() const {
     return *impl->irs_shared_mem;
 }
 
-Kernel::SharedMemory& KernelCore::GetTimeSharedMem() {
+Kernel::KSharedMemory& KernelCore::GetTimeSharedMem() {
     return *impl->time_shared_mem;
 }
 
-const Kernel::SharedMemory& KernelCore::GetTimeSharedMem() const {
+const Kernel::KSharedMemory& KernelCore::GetTimeSharedMem() const {
     return *impl->time_shared_mem;
 }