From 68ddaaa2f5726e3619accee77b488ec285f3a2d7 Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 20 Jan 2015 20:53:52 -0500 Subject: Thread: Fix WaitSynchronization1 to not set register 1 on thread wakeup. --- src/core/hle/kernel/thread.cpp | 43 +++++++++++++++++++++++++++--------------- src/core/hle/kernel/thread.h | 21 ++++++++++++++------- 2 files changed, 42 insertions(+), 22 deletions(-) (limited to 'src/core/hle/kernel') diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp index 58523e145..03b492c75 100644 --- a/src/core/hle/kernel/thread.cpp +++ b/src/core/hle/kernel/thread.cpp @@ -205,25 +205,24 @@ static Thread* NextThread() { void WaitCurrentThread_Sleep() { Thread* thread = GetCurrentThread(); - thread->wait_all = false; - thread->wait_address = 0; - thread->wait_objects.clear(); ChangeThreadState(thread, ThreadStatus(THREADSTATUS_WAIT | (thread->status & THREADSTATUS_SUSPEND))); } -void WaitCurrentThread_WaitSynchronization(SharedPtr wait_object, bool wait_all) { +void WaitCurrentThread_WaitSynchronization(SharedPtr wait_object, bool wait_set_output, bool wait_all) { Thread* thread = GetCurrentThread(); + thread->wait_set_output = wait_set_output; thread->wait_all = wait_all; - thread->wait_address = 0; - thread->wait_objects.push_back(wait_object); + + // It's possible to call WaitSynchronizationN without any objects passed in... + if (wait_object != nullptr) + thread->wait_objects.push_back(wait_object); + ChangeThreadState(thread, ThreadStatus(THREADSTATUS_WAIT | (thread->status & THREADSTATUS_SUSPEND))); } void WaitCurrentThread_ArbitrateAddress(VAddr wait_address) { Thread* thread = GetCurrentThread(); - thread->wait_all = false; thread->wait_address = wait_address; - thread->wait_objects.clear(); ChangeThreadState(thread, ThreadStatus(THREADSTATUS_WAIT | (thread->status & THREADSTATUS_SUSPEND))); } @@ -239,8 +238,11 @@ static void ThreadWakeupCallback(u64 parameter, int cycles_late) { return; } - thread->SetReturnValue(ResultCode(ErrorDescription::Timeout, ErrorModule::OS, - ErrorSummary::StatusChanged, ErrorLevel::Info), -1); + thread->SetWaitSynchronizationResult(ResultCode(ErrorDescription::Timeout, ErrorModule::OS, + ErrorSummary::StatusChanged, ErrorLevel::Info)); + + if (thread->wait_set_output) + thread->SetWaitSynchronizationOutput(-1); thread->ResumeFromWait(); } @@ -282,12 +284,18 @@ void Thread::ReleaseWaitObject(WaitObject* wait_object) { if (wait_all) { // Resume the thread only if all are available... if (!wait_all_failed) { - SetReturnValue(RESULT_SUCCESS, -1); + SetWaitSynchronizationResult(RESULT_SUCCESS); + SetWaitSynchronizationOutput(-1); + ResumeFromWait(); } } else { // Otherwise, resume - SetReturnValue(RESULT_SUCCESS, index); + SetWaitSynchronizationResult(RESULT_SUCCESS); + + if (wait_set_output) + SetWaitSynchronizationOutput(index); + ResumeFromWait(); } } @@ -303,6 +311,7 @@ void Thread::ResumeFromWait() { wait_object->RemoveWaitingThread(this); wait_objects.clear(); + wait_set_output = false; wait_all = false; wait_address = 0; @@ -371,6 +380,7 @@ ResultVal> Thread::Create(std::string name, VAddr entry_point, thread->stack_size = stack_size; thread->initial_priority = thread->current_priority = priority; thread->processor_id = processor_id; + thread->wait_set_output = false; thread->wait_all = false; thread->wait_objects.clear(); thread->wait_address = 0; @@ -462,9 +472,12 @@ void Reschedule() { } } -void Thread::SetReturnValue(ResultCode return_val, s32 out_val) { - context.cpu_registers[0] = return_val.raw; - context.cpu_registers[1] = out_val; +void Thread::SetWaitSynchronizationResult(ResultCode result) { + context.cpu_registers[0] = result.raw; +} + +void Thread::SetWaitSynchronizationOutput(s32 output) { + context.cpu_registers[1] = output; } //////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h index bed9f714a..5fab1ab58 100644 --- a/src/core/hle/kernel/thread.h +++ b/src/core/hle/kernel/thread.h @@ -78,11 +78,16 @@ public: void ResumeFromWait(); /** - * Sets the output values after the thread awakens from WaitSynchronization - * @param return_val Value returned - * @param out_val Value to set to the output parameter + * Sets the result after the thread awakens (from either WaitSynchronization SVC) + * @param result Value to set to the returned result */ - void SetReturnValue(ResultCode return_val, s32 out_val); + void SetWaitSynchronizationResult(ResultCode result); + + /** + * Sets the output parameter value after the thread awakens (from WaitSynchronizationN SVC only) + * @param output Value to set to the output parameter + */ + void SetWaitSynchronizationOutput(s32 output); Core::ThreadContext context; @@ -100,8 +105,9 @@ public: std::vector> wait_objects; ///< Objects that the thread is waiting on - VAddr wait_address; ///< If waiting on an AddressArbiter, this is the arbitration address - bool wait_all; ///< True if the thread is waiting on all objects before resuming + VAddr wait_address; ///< If waiting on an AddressArbiter, this is the arbitration address + bool wait_all; ///< True if the thread is waiting on all objects before resuming + bool wait_set_output; ///< True if the output parameter should be set on thread wakeup std::string name; @@ -134,9 +140,10 @@ void WaitCurrentThread_Sleep(); /** * Waits the current thread from a WaitSynchronization call * @param wait_object Kernel object that we are waiting on + * @param wait_set_output If true, set the output parameter on thread wakeup (for WaitSynchronizationN only) * @param wait_all If true, wait on all objects before resuming (for WaitSynchronizationN only) */ -void WaitCurrentThread_WaitSynchronization(SharedPtr wait_object, bool wait_all = false); +void WaitCurrentThread_WaitSynchronization(SharedPtr wait_object, bool wait_set_output, bool wait_all); /** * Waits the current thread from an ArbitrateAddress call -- cgit v1.2.3