From b9950cd4b0cf414ca97daa5f7578f4ca22b2669d Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 1 Jan 2018 14:02:26 -0500 Subject: [PATCH] svc: Implement svcLockMutex. --- src/core/hle/kernel/mutex.cpp | 81 +++++++++++++++++++++++++++-------- src/core/hle/kernel/mutex.h | 37 +++++++++++++--- src/core/hle/svc.cpp | 40 ++++++++++++++++- 3 files changed, 134 insertions(+), 24 deletions(-) diff --git a/src/core/hle/kernel/mutex.cpp b/src/core/hle/kernel/mutex.cpp index 30dade552..1b7cda740 100644 --- a/src/core/hle/kernel/mutex.cpp +++ b/src/core/hle/kernel/mutex.cpp @@ -7,8 +7,10 @@ #include #include "common/assert.h" #include "core/core.h" +#include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/mutex.h" +#include "core/hle/kernel/object_address_table.h" #include "core/hle/kernel/thread.h" namespace Kernel { @@ -25,17 +27,25 @@ void ReleaseThreadMutexes(Thread* thread) { Mutex::Mutex() {} Mutex::~Mutex() {} -SharedPtr Mutex::Create(bool initial_locked, VAddr addr, std::string name) { +SharedPtr Mutex::Create(SharedPtr holding_thread, VAddr guest_addr, + std::string name) { SharedPtr mutex(new Mutex); mutex->lock_count = 0; - mutex->addr = addr; + mutex->guest_addr = guest_addr; mutex->name = std::move(name); mutex->holding_thread = nullptr; - // Acquire mutex with current thread if initialized as locked - if (initial_locked) - mutex->Acquire(GetCurrentThread()); + // If mutex was initialized with a holding thread, acquire it by the holding thread + if (holding_thread) { + mutex->Acquire(holding_thread.get()); + } + + // Mutexes are referenced by guest address, so track this in the kernel + g_object_address_table.Insert(guest_addr, mutex); + + // Verify that the created mutex matches the guest state for the mutex + mutex->VerifyGuestState(); return mutex; } @@ -53,38 +63,60 @@ void Mutex::Acquire(Thread* thread) { thread->held_mutexes.insert(this); holding_thread = thread; thread->UpdatePriority(); + UpdateGuestState(); Core::System::GetInstance().PrepareReschedule(); } lock_count++; } -void Mutex::Release() { - // Only release if the mutex is held - if (lock_count > 0) { - lock_count--; - - // Yield to the next thread only if we've fully released the mutex - if (lock_count == 0) { - holding_thread->held_mutexes.erase(this); - holding_thread->UpdatePriority(); - holding_thread = nullptr; - WakeupAllWaitingThreads(); - Core::System::GetInstance().PrepareReschedule(); +ResultCode Mutex::Release(Thread* thread) { + // We can only release the mutex if it's held by the calling thread. + if (thread != holding_thread) { + if (holding_thread) { + LOG_ERROR( + Kernel, + "Tried to release a mutex (owned by thread id %u) from a different thread id %u", + holding_thread->thread_id, thread->thread_id); } + // TODO(bunnei): Use correct error code + return ResultCode(-1); } + + // Note: It should not be possible for the situation where the mutex has a holding thread with a + // zero lock count to occur. The real kernel still checks for this, so we do too. + if (lock_count <= 0) { + // TODO(bunnei): Use correct error code + return ResultCode(-1); + } + + lock_count--; + + // Yield to the next thread only if we've fully released the mutex + if (lock_count == 0) { + holding_thread->held_mutexes.erase(this); + holding_thread->UpdatePriority(); + holding_thread = nullptr; + WakeupAllWaitingThreads(); + UpdateGuestState(); + Core::System::GetInstance().PrepareReschedule(); + } + + return RESULT_SUCCESS; } void Mutex::AddWaitingThread(SharedPtr thread) { WaitObject::AddWaitingThread(thread); thread->pending_mutexes.insert(this); UpdatePriority(); + UpdateGuestState(); } void Mutex::RemoveWaitingThread(Thread* thread) { WaitObject::RemoveWaitingThread(thread); thread->pending_mutexes.erase(this); UpdatePriority(); + UpdateGuestState(); } void Mutex::UpdatePriority() { @@ -103,4 +135,17 @@ void Mutex::UpdatePriority() { } } -} // namespace +void Mutex::UpdateGuestState() { + GuestState guest_state{Memory::Read32(guest_addr)}; + guest_state.has_waiters.Assign(!GetWaitingThreads().empty()); + guest_state.holding_thread_handle.Assign(holding_thread ? holding_thread->guest_handle : 0); + Memory::Write32(guest_addr, guest_state.raw); +} + +void Mutex::VerifyGuestState() { + GuestState guest_state{Memory::Read32(guest_addr)}; + ASSERT(guest_state.has_waiters == !GetWaitingThreads().empty()); + ASSERT(guest_state.holding_thread_handle == holding_thread->guest_handle); +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/mutex.h b/src/core/hle/kernel/mutex.h index 503d3ee75..87e3c15ee 100644 --- a/src/core/hle/kernel/mutex.h +++ b/src/core/hle/kernel/mutex.h @@ -6,8 +6,10 @@ #include #include "common/common_types.h" +#include "common/swap.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/wait_object.h" +#include "core/hle/result.h" namespace Kernel { @@ -17,11 +19,15 @@ class Mutex final : public WaitObject { public: /** * Creates a mutex. - * @param initial_locked Specifies if the mutex should be locked initially + * @param holding_thread Specifies a thread already holding the mutex. If not nullptr, this + * thread will acquire the mutex. + * @param guest_addr Address of the object tracking the mutex in guest memory. If specified, + * this mutex will update the guest object when its state changes. * @param name Optional name of mutex * @return Pointer to new Mutex object */ - static SharedPtr Create(bool initial_locked, VAddr addr, std::string name = "Unknown"); + static SharedPtr Create(SharedPtr holding_thread, VAddr guest_addr = 0, + std::string name = "Unknown"); std::string GetTypeName() const override { return "Mutex"; @@ -39,7 +45,7 @@ public: u32 priority; ///< The priority of the mutex, used for priority inheritance. std::string name; ///< Name of mutex (optional) SharedPtr holding_thread; ///< Thread that has acquired the mutex - VAddr addr; + VAddr guest_addr; ///< Address of the guest mutex value /** * Elevate the mutex priority to the best priority @@ -53,11 +59,32 @@ public: void AddWaitingThread(SharedPtr thread) override; void RemoveWaitingThread(Thread* thread) override; - void Release(); + /** + * Attempts to release the mutex from the specified thread. + * @param thread Thread that wants to release the mutex. + * @returns The result code of the operation. + */ + ResultCode Release(Thread* thread); private: Mutex(); ~Mutex() override; + + /// Object in guest memory used to track the mutex state + union GuestState { + u32_le raw; + /// Handle of the thread that currently holds the mutex, 0 if available + BitField<0, 30, u32_le> holding_thread_handle; + /// 1 when there are threads waiting for this mutex, otherwise 0 + BitField<30, 1, u32_le> has_waiters; + }; + static_assert(sizeof(GuestState) == 4, "GuestState size is incorrect"); + + /// Updates the state of the object tracking this mutex in guest memory + void UpdateGuestState(); + + /// Verifies the state of the object tracking this mutex in guest memory + void VerifyGuestState(); }; /** @@ -66,4 +93,4 @@ private: */ void ReleaseThreadMutexes(Thread* thread); -} // namespace +} // namespace Kernel diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp index 133b868f2..c0e3200d4 100644 --- a/src/core/hle/svc.cpp +++ b/src/core/hle/svc.cpp @@ -122,6 +122,44 @@ static ResultCode GetProcessId(u32* process_id, Kernel::Handle process_handle) { return RESULT_SUCCESS; } +/// Attempts to locks a mutex, creating it if it does not already exist +static ResultCode LockMutex(Handle holding_thread_handle, VAddr mutex_addr, + Handle requesting_thread_handle) { + LOG_TRACE(Kernel_SVC, + "called holding_thread_handle=0x%08X, mutex_addr=0x%llx, " + "requesting_current_thread_handle=0x%08X", + holding_thread_handle, mutex_addr, requesting_thread_handle); + + SharedPtr holding_thread = + Kernel::g_handle_table.Get(holding_thread_handle); + SharedPtr requesting_thread = + Kernel::g_handle_table.Get(requesting_thread_handle); + + ASSERT(holding_thread); + ASSERT(requesting_thread); + + SharedPtr mutex = Kernel::g_object_address_table.Get(mutex_addr); + if (!mutex) { + // Create a new mutex for the specified address if one does not already exist + mutex = Kernel::Mutex::Create(holding_thread, mutex_addr); + mutex->name = Common::StringFromFormat("mutex-%llx", mutex_addr); + } + + if (mutex->ShouldWait(requesting_thread.get())) { + // If we cannot lock the mutex, then put the thread too sleep and trigger a reschedule + requesting_thread->wait_objects = {mutex}; + mutex->AddWaitingThread(requesting_thread); + requesting_thread->status = THREADSTATUS_WAIT_SYNCH_ANY; + + Core::System::GetInstance().PrepareReschedule(); + } else { + // The mutex is available, lock it + mutex->Acquire(requesting_thread.get()); + } + + return RESULT_SUCCESS; +} + /// Break program execution static void Break(u64 unk_0, u64 unk_1, u64 unk_2) { LOG_CRITICAL(Debug_Emulated, "Emulated program broke execution!"); @@ -371,8 +409,8 @@ static const FunctionDef SVC_Table[] = { {0x17, nullptr, "svcResetSignal"}, {0x18, nullptr, "svcWaitSynchronization"}, {0x19, nullptr, "svcCancelSynchronization"}, - {0x1A, nullptr, "svcLockMutex"}, {0x1B, nullptr, "svcUnlockMutex"}, + {0x1A, HLE::Wrap, "svcLockMutex"}, {0x1C, nullptr, "svcWaitProcessWideKeyAtomic"}, {0x1D, HLE::Wrap, "svcSignalProcessWideKey"}, {0x1E, nullptr, "svcGetSystemTick"},