early-access version 3038

src/core/hle/kernel/kernel.cpp

@@ -24,7 +24,6 @@
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/init/init_slab_setup.h"
 #include "core/hle/kernel/k_client_port.h"
-#include "core/hle/kernel/k_dynamic_resource_manager.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
@@ -74,16 +73,8 @@ struct KernelCore::Impl {
         InitializeMemoryLayout();
         Init::InitializeKPageBufferSlabHeap(system);
         InitializeShutdownThreads();
-        InitializePhysicalCores();
         InitializePreemption(kernel);
-
-        // Initialize the Dynamic Slab Heaps.
-        {
-            const auto& pt_heap_region = memory_layout->GetPageTableHeapRegion();
-            ASSERT(pt_heap_region.GetEndAddress() != 0);
-
-            InitializeResourceManagers(pt_heap_region.GetAddress(), pt_heap_region.GetSize());
-        }
+        InitializePhysicalCores();
 
         RegisterHostThread();
     }
@@ -95,15 +86,6 @@ struct KernelCore::Impl {
         }
     }
 
-    void CloseCurrentProcess() {
-        (*current_process).Finalize();
-        // current_process->Close();
-        // TODO: The current process should be destroyed based on accurate ref counting after
-        // calling Close(). Adding a manual Destroy() call instead to avoid a memory leak.
-        (*current_process).Destroy();
-        current_process = nullptr;
-    }
-
     void Shutdown() {
         is_shutting_down.store(true, std::memory_order_relaxed);
         SCOPE_EXIT({ is_shutting_down.store(false, std::memory_order_relaxed); });
@@ -117,6 +99,10 @@ struct KernelCore::Impl {
         next_user_process_id = KProcess::ProcessIDMin;
         next_thread_id = 1;
 
+        for (auto& core : cores) {
+            core = nullptr;
+        }
+
         global_handle_table->Finalize();
         global_handle_table.reset();
 
@@ -166,7 +152,15 @@ struct KernelCore::Impl {
             }
         }
 
-        CloseCurrentProcess();
+        // Shutdown all processes.
+        if (current_process) {
+            (*current_process).Finalize();
+            // current_process->Close();
+            // TODO: The current process should be destroyed based on accurate ref counting after
+            // calling Close(). Adding a manual Destroy() call instead to avoid a memory leak.
+            (*current_process).Destroy();
+            current_process = nullptr;
+        }
 
         // Track kernel objects that were not freed on shutdown
         {
@@ -263,18 +257,6 @@ struct KernelCore::Impl {
         system.CoreTiming().ScheduleLoopingEvent(time_interval, time_interval, preemption_event);
     }
 
-    void InitializeResourceManagers(VAddr address, size_t size) {
-        dynamic_page_manager = std::make_unique<KDynamicPageManager>();
-        memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>();
-        app_memory_block_manager = std::make_unique<KMemoryBlockSlabManager>();
-
-        dynamic_page_manager->Initialize(address, size);
-        static constexpr size_t ApplicationMemoryBlockSlabHeapSize = 20000;
-        memory_block_heap->Initialize(dynamic_page_manager.get(),
-                                      ApplicationMemoryBlockSlabHeapSize);
-        app_memory_block_manager->Initialize(nullptr, memory_block_heap.get());
-    }
-
     void InitializeShutdownThreads() {
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
             shutdown_threads[core_id] = KThread::Create(system.Kernel());
@@ -362,6 +344,11 @@ struct KernelCore::Impl {
     static inline thread_local KThread* current_thread{nullptr};
 
     KThread* GetCurrentEmuThread() {
+        // If we are shutting down the kernel, none of this is relevant anymore.
+        if (IsShuttingDown()) {
+            return {};
+        }
+
         const auto thread_id = GetCurrentHostThreadID();
         if (thread_id >= Core::Hardware::NUM_CPU_CORES) {
             return GetHostDummyThread();
@@ -783,11 +770,6 @@ struct KernelCore::Impl {
     // Kernel memory management
     std::unique_ptr<KMemoryManager> memory_manager;
 
-    // Dynamic slab managers
-    std::unique_ptr<KDynamicPageManager> dynamic_page_manager;
-    std::unique_ptr<KMemoryBlockSlabHeap> memory_block_heap;
-    std::unique_ptr<KMemoryBlockSlabManager> app_memory_block_manager;
-
     // Shared memory for services
     Kernel::KSharedMemory* hid_shared_mem{};
     Kernel::KSharedMemory* font_shared_mem{};
@@ -871,10 +853,6 @@ const KProcess* KernelCore::CurrentProcess() const {
     return impl->current_process;
 }
 
-void KernelCore::CloseCurrentProcess() {
-    impl->CloseCurrentProcess();
-}
-
 const std::vector<KProcess*>& KernelCore::GetProcessList() const {
     return impl->process_list;
 }
@@ -1063,14 +1041,6 @@ const KMemoryManager& KernelCore::MemoryManager() const {
     return *impl->memory_manager;
 }
 
-KMemoryBlockSlabManager& KernelCore::GetApplicationMemoryBlockManager() {
-    return *impl->app_memory_block_manager;
-}
-
-const KMemoryBlockSlabManager& KernelCore::GetApplicationMemoryBlockManager() const {
-    return *impl->app_memory_block_manager;
-}
-
 Kernel::KSharedMemory& KernelCore::GetHidSharedMem() {
     return *impl->hid_shared_mem;
 }