From 9704acb982eb3dfb4b2b6a090f5613d4ac57b196 Mon Sep 17 00:00:00 2001 From: Liam Date: Tue, 6 Dec 2022 16:13:42 -0500 Subject: [PATCH] general: improve handling of system startup failure --- src/common/thread.h | 11 +++++++---- src/core/core.cpp | 4 +++- src/core/cpu_manager.cpp | 15 +++++++-------- src/core/cpu_manager.h | 4 +--- src/core/hle/kernel/kernel.cpp | 14 +++++++++----- 5 files changed, 27 insertions(+), 21 deletions(-) diff --git a/src/common/thread.h b/src/common/thread.h index e17a7850f..8ae169b4e 100644 --- a/src/common/thread.h +++ b/src/common/thread.h @@ -11,6 +11,7 @@ #include #include #include "common/common_types.h" +#include "common/polyfill_thread.h" namespace Common { @@ -69,7 +70,7 @@ public: explicit Barrier(std::size_t count_) : count(count_) {} /// Blocks until all "count" threads have called Sync() - void Sync() { + bool Sync(std::stop_token token = {}) { std::unique_lock lk{mutex}; const std::size_t current_generation = generation; @@ -77,14 +78,16 @@ public: generation++; waiting = 0; condvar.notify_all(); + return true; } else { - condvar.wait(lk, - [this, current_generation] { return current_generation != generation; }); + CondvarWait(condvar, lk, token, + [this, current_generation] { return current_generation != generation; }); + return !token.stop_requested(); } } private: - std::condition_variable condvar; + std::condition_variable_any condvar; std::mutex mutex; std::size_t count; std::size_t waiting = 0; diff --git a/src/core/core.cpp b/src/core/core.cpp index 94d4e2212..a738f221f 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -389,7 +389,9 @@ struct System::Impl { kernel.ShutdownCores(); cpu_manager.Shutdown(); debugger.reset(); - services->KillNVNFlinger(); + if (services) { + services->KillNVNFlinger(); + } kernel.CloseServices(); services.reset(); service_manager.reset(); diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cpp index 0dd4c2196..04a11f444 100644 --- a/src/core/cpu_manager.cpp +++ b/src/core/cpu_manager.cpp @@ -20,23 +20,20 @@ namespace Core { CpuManager::CpuManager(System& system_) : system{system_} {} CpuManager::~CpuManager() = default; -void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, - std::size_t core) { - cpu_manager.RunThread(core); -} - void CpuManager::Initialize() { num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1; gpu_barrier = std::make_unique(num_cores + 1); for (std::size_t core = 0; core < num_cores; core++) { - core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core); + core_data[core].host_thread = + std::jthread([this, core](std::stop_token token) { RunThread(token, core); }); } } void CpuManager::Shutdown() { for (std::size_t core = 0; core < num_cores; core++) { if (core_data[core].host_thread.joinable()) { + core_data[core].host_thread.request_stop(); core_data[core].host_thread.join(); } } @@ -184,7 +181,7 @@ void CpuManager::ShutdownThread() { UNREACHABLE(); } -void CpuManager::RunThread(std::size_t core) { +void CpuManager::RunThread(std::stop_token token, std::size_t core) { /// Initialization system.RegisterCoreThread(core); std::string name; @@ -206,7 +203,9 @@ void CpuManager::RunThread(std::size_t core) { }); // Running - gpu_barrier->Sync(); + if (!gpu_barrier->Sync(token)) { + return; + } if (!is_async_gpu && !is_multicore) { system.GPU().ObtainContext(); diff --git a/src/core/cpu_manager.h b/src/core/cpu_manager.h index 374367468..0deea9c58 100644 --- a/src/core/cpu_manager.h +++ b/src/core/cpu_manager.h @@ -81,12 +81,10 @@ private: void SingleCoreRunGuestThread(); void SingleCoreRunIdleThread(); - static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core); - void GuestActivate(); void HandleInterrupt(); void ShutdownThread(); - void RunThread(std::size_t core); + void RunThread(std::stop_token stop_token, std::size_t core); struct CoreData { std::shared_ptr host_context; diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 288f97df5..0eb74a422 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -104,12 +104,16 @@ struct KernelCore::Impl { } void CloseCurrentProcess() { - (*current_process).Finalize(); - // current_process->Close(); - // TODO: The current process should be destroyed based on accurate ref counting after + KProcess* old_process = current_process.exchange(nullptr); + if (old_process == nullptr) { + return; + } + + // old_process->Close(); + // TODO: The 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; + old_process->Finalize(); + old_process->Destroy(); } void Shutdown() {