early-access version 2817

src/core/hle/kernel/k_thread.cpp

@@ -269,7 +269,7 @@ Result KThread::InitializeIdleThread(Core::System& system, KThread* thread, s32
 Result KThread::InitializeHighPriorityThread(Core::System& system, KThread* thread,
                                              KThreadFunction func, uintptr_t arg, s32 virt_core) {
     return InitializeThread(thread, func, arg, {}, {}, virt_core, nullptr, ThreadType::HighPriority,
-                            system.GetCpuManager().GetShutdownThreadStartFunc());
+                            system.GetCpuManager().GetSuspendThreadStartFunc());
 }
 
 Result KThread::InitializeUserThread(Core::System& system, KThread* thread, KThreadFunction func,
@@ -739,19 +739,6 @@ void KThread::Continue() {
     KScheduler::OnThreadStateChanged(kernel, this, old_state);
 }
 
-void KThread::WaitUntilSuspended() {
-    // Make sure we have a suspend requested.
-    ASSERT(IsSuspendRequested());
-
-    // Loop until the thread is not executing on any core.
-    for (std::size_t i = 0; i < static_cast<std::size_t>(Core::Hardware::NUM_CPU_CORES); ++i) {
-        KThread* core_thread{};
-        do {
-            core_thread = kernel.Scheduler(i).GetSchedulerCurrentThread();
-        } while (core_thread == this);
-    }
-}
-
 Result KThread::SetActivity(Svc::ThreadActivity activity) {
     // Lock ourselves.
     KScopedLightLock lk(activity_pause_lock);

src/core/hle/kernel/k_thread.h

@@ -208,8 +208,6 @@ public:
 
     void Continue();
 
-    void WaitUntilSuspended();
-
     constexpr void SetSyncedIndex(s32 index) {
         synced_index = index;
     }

src/core/hle/kernel/kernel.cpp

@@ -76,7 +76,7 @@ struct KernelCore::Impl {
         InitializeMemoryLayout();
         Init::InitializeKPageBufferSlabHeap(system);
         InitializeSchedulers();
-        InitializeShutdownThreads();
+        InitializeSuspendThreads();
         InitializePreemption(kernel);
 
         RegisterHostThread();
@@ -143,9 +143,9 @@ struct KernelCore::Impl {
         CleanupObject(system_resource_limit);
 
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            if (shutdown_threads[core_id]) {
-                shutdown_threads[core_id]->Close();
-                shutdown_threads[core_id] = nullptr;
+            if (suspend_threads[core_id]) {
+                suspend_threads[core_id]->Close();
+                suspend_threads[core_id] = nullptr;
             }
 
             schedulers[core_id]->Finalize();
@@ -247,13 +247,13 @@ struct KernelCore::Impl {
         system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
     }
 
-    void InitializeShutdownThreads() {
+    void InitializeSuspendThreads() {
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            shutdown_threads[core_id] = KThread::Create(system.Kernel());
-            ASSERT(KThread::InitializeHighPriorityThread(system, shutdown_threads[core_id], {}, {},
+            suspend_threads[core_id] = KThread::Create(system.Kernel());
+            ASSERT(KThread::InitializeHighPriorityThread(system, suspend_threads[core_id], {}, {},
                                                          core_id)
                        .IsSuccess());
-            shutdown_threads[core_id]->SetName(fmt::format("SuspendThread:{}", core_id));
+            suspend_threads[core_id]->SetName(fmt::format("SuspendThread:{}", core_id));
         }
     }
 
@@ -775,7 +775,7 @@ struct KernelCore::Impl {
     std::weak_ptr<ServiceThread> default_service_thread;
     Common::ThreadWorker service_threads_manager;
 
-    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads;
+    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> suspend_threads;
     std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES> interrupts{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
@@ -1085,27 +1085,16 @@ const Kernel::KSharedMemory& KernelCore::GetHidBusSharedMem() const {
 
 void KernelCore::Suspend(bool suspended) {
     const bool should_suspend{exception_exited || suspended};
-    const auto activity = should_suspend ? ProcessActivity::Paused : ProcessActivity::Runnable;
-
-    for (auto* process : GetProcessList()) {
-        process->SetActivity(activity);
-
-        if (should_suspend) {
-            // Wait for execution to stop
-            for (auto* thread : process->GetThreadList()) {
-                thread->WaitUntilSuspended();
-            }
+    const auto state{should_suspend ? ThreadState::Runnable : ThreadState::Waiting};
+    {
+        KScopedSchedulerLock lk{*this};
+        for (auto* thread : impl->suspend_threads) {
+            thread->SetState(state);
+            thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Suspended);
         }
     }
 }
 
-void KernelCore::ShutdownCores() {
-    for (auto* thread : impl->shutdown_threads) {
-        void(thread->Run());
-    }
-    InterruptAllPhysicalCores();
-}
-
 bool KernelCore::IsMulticore() const {
     return impl->is_multicore;
 }

src/core/hle/kernel/kernel.h

@@ -280,9 +280,6 @@ public:
     /// Exceptional exit all processes.
     void ExceptionalExit();
 
-    /// Notify emulated CPU cores to shut down.
-    void ShutdownCores();
-
     bool IsMulticore() const;
 
     bool IsShuttingDown() const;