Merge pull request #2393 from Subv/synch
Kernel: Mutex priority inheritance and synchronization improvements.
This commit is contained in:
		| @@ -153,7 +153,8 @@ QString WaitTreeThread::GetText() const { | |||||||
|     case THREADSTATUS_WAIT_SLEEP: |     case THREADSTATUS_WAIT_SLEEP: | ||||||
|         status = tr("sleeping"); |         status = tr("sleeping"); | ||||||
|         break; |         break; | ||||||
|     case THREADSTATUS_WAIT_SYNCH: |     case THREADSTATUS_WAIT_SYNCH_ALL: | ||||||
|  |     case THREADSTATUS_WAIT_SYNCH_ANY: | ||||||
|         status = tr("waiting for objects"); |         status = tr("waiting for objects"); | ||||||
|         break; |         break; | ||||||
|     case THREADSTATUS_DORMANT: |     case THREADSTATUS_DORMANT: | ||||||
| @@ -180,7 +181,8 @@ QColor WaitTreeThread::GetColor() const { | |||||||
|         return QColor(Qt::GlobalColor::darkRed); |         return QColor(Qt::GlobalColor::darkRed); | ||||||
|     case THREADSTATUS_WAIT_SLEEP: |     case THREADSTATUS_WAIT_SLEEP: | ||||||
|         return QColor(Qt::GlobalColor::darkYellow); |         return QColor(Qt::GlobalColor::darkYellow); | ||||||
|     case THREADSTATUS_WAIT_SYNCH: |     case THREADSTATUS_WAIT_SYNCH_ALL: | ||||||
|  |     case THREADSTATUS_WAIT_SYNCH_ANY: | ||||||
|         return QColor(Qt::GlobalColor::red); |         return QColor(Qt::GlobalColor::red); | ||||||
|     case THREADSTATUS_DORMANT: |     case THREADSTATUS_DORMANT: | ||||||
|         return QColor(Qt::GlobalColor::darkCyan); |         return QColor(Qt::GlobalColor::darkCyan); | ||||||
| @@ -228,7 +230,8 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const { | |||||||
|     } else { |     } else { | ||||||
|         list.push_back(std::make_unique<WaitTreeMutexList>(thread.held_mutexes)); |         list.push_back(std::make_unique<WaitTreeMutexList>(thread.held_mutexes)); | ||||||
|     } |     } | ||||||
|     if (thread.status == THREADSTATUS_WAIT_SYNCH) { |     if (thread.status == THREADSTATUS_WAIT_SYNCH_ANY || | ||||||
|  |         thread.status == THREADSTATUS_WAIT_SYNCH_ALL) { | ||||||
|         list.push_back(std::make_unique<WaitTreeObjectList>(thread.wait_objects, |         list.push_back(std::make_unique<WaitTreeObjectList>(thread.wait_objects, | ||||||
|                                                             thread.IsSleepingOnWaitAll())); |                                                             thread.IsSleepingOnWaitAll())); | ||||||
|     } |     } | ||||||
|   | |||||||
| @@ -30,12 +30,12 @@ SharedPtr<Event> Event::Create(ResetType reset_type, std::string name) { | |||||||
|     return evt; |     return evt; | ||||||
| } | } | ||||||
|  |  | ||||||
| bool Event::ShouldWait() { | bool Event::ShouldWait(Thread* thread) const { | ||||||
|     return !signaled; |     return !signaled; | ||||||
| } | } | ||||||
|  |  | ||||||
| void Event::Acquire() { | void Event::Acquire(Thread* thread) { | ||||||
|     ASSERT_MSG(!ShouldWait(), "object unavailable!"); |     ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); | ||||||
|  |  | ||||||
|     // Release the event if it's not sticky... |     // Release the event if it's not sticky... | ||||||
|     if (reset_type != ResetType::Sticky) |     if (reset_type != ResetType::Sticky) | ||||||
|   | |||||||
| @@ -35,8 +35,8 @@ public: | |||||||
|     bool signaled;    ///< Whether the event has already been signaled |     bool signaled;    ///< Whether the event has already been signaled | ||||||
|     std::string name; ///< Name of event (optional) |     std::string name; ///< Name of event (optional) | ||||||
|  |  | ||||||
|     bool ShouldWait() override; |     bool ShouldWait(Thread* thread) const override; | ||||||
|     void Acquire() override; |     void Acquire(Thread* thread) override; | ||||||
|  |  | ||||||
|     void Signal(); |     void Signal(); | ||||||
|     void Clear(); |     void Clear(); | ||||||
|   | |||||||
| @@ -3,7 +3,6 @@ | |||||||
| // Refer to the license.txt file included. | // Refer to the license.txt file included. | ||||||
|  |  | ||||||
| #include <algorithm> | #include <algorithm> | ||||||
| #include <boost/range/algorithm_ext/erase.hpp> |  | ||||||
| #include "common/assert.h" | #include "common/assert.h" | ||||||
| #include "common/logging/log.h" | #include "common/logging/log.h" | ||||||
| #include "core/hle/config_mem.h" | #include "core/hle/config_mem.h" | ||||||
| @@ -28,32 +27,39 @@ void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) { | |||||||
|  |  | ||||||
| void WaitObject::RemoveWaitingThread(Thread* thread) { | void WaitObject::RemoveWaitingThread(Thread* thread) { | ||||||
|     auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread); |     auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread); | ||||||
|  |     // If a thread passed multiple handles to the same object, | ||||||
|  |     // the kernel might attempt to remove the thread from the object's | ||||||
|  |     // waiting threads list multiple times. | ||||||
|     if (itr != waiting_threads.end()) |     if (itr != waiting_threads.end()) | ||||||
|         waiting_threads.erase(itr); |         waiting_threads.erase(itr); | ||||||
| } | } | ||||||
|  |  | ||||||
| SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() { | SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() { | ||||||
|     // Remove the threads that are ready or already running from our waitlist |  | ||||||
|     boost::range::remove_erase_if(waiting_threads, [](const SharedPtr<Thread>& thread) { |  | ||||||
|         return thread->status == THREADSTATUS_RUNNING || thread->status == THREADSTATUS_READY || |  | ||||||
|                thread->status == THREADSTATUS_DEAD; |  | ||||||
|     }); |  | ||||||
|  |  | ||||||
|     // TODO(Subv): This call should be performed inside the loop below to check if an object can be |  | ||||||
|     // acquired by a particular thread. This is useful for things like recursive locking of Mutexes. |  | ||||||
|     if (ShouldWait()) |  | ||||||
|         return nullptr; |  | ||||||
|  |  | ||||||
|     Thread* candidate = nullptr; |     Thread* candidate = nullptr; | ||||||
|     s32 candidate_priority = THREADPRIO_LOWEST + 1; |     s32 candidate_priority = THREADPRIO_LOWEST + 1; | ||||||
|  |  | ||||||
|     for (const auto& thread : waiting_threads) { |     for (const auto& thread : waiting_threads) { | ||||||
|  |         // The list of waiting threads must not contain threads that are not waiting to be awakened. | ||||||
|  |         ASSERT_MSG(thread->status == THREADSTATUS_WAIT_SYNCH_ANY || | ||||||
|  |                        thread->status == THREADSTATUS_WAIT_SYNCH_ALL, | ||||||
|  |                    "Inconsistent thread statuses in waiting_threads"); | ||||||
|  |  | ||||||
|         if (thread->current_priority >= candidate_priority) |         if (thread->current_priority >= candidate_priority) | ||||||
|             continue; |             continue; | ||||||
|  |  | ||||||
|         bool ready_to_run = |         if (ShouldWait(thread.get())) | ||||||
|             std::none_of(thread->wait_objects.begin(), thread->wait_objects.end(), |             continue; | ||||||
|                          [](const SharedPtr<WaitObject>& object) { return object->ShouldWait(); }); |  | ||||||
|  |         // A thread is ready to run if it's either in THREADSTATUS_WAIT_SYNCH_ANY or | ||||||
|  |         // in THREADSTATUS_WAIT_SYNCH_ALL and the rest of the objects it is waiting on are ready. | ||||||
|  |         bool ready_to_run = true; | ||||||
|  |         if (thread->status == THREADSTATUS_WAIT_SYNCH_ALL) { | ||||||
|  |             ready_to_run = std::none_of(thread->wait_objects.begin(), thread->wait_objects.end(), | ||||||
|  |                                         [&thread](const SharedPtr<WaitObject>& object) { | ||||||
|  |                                             return object->ShouldWait(thread.get()); | ||||||
|  |                                         }); | ||||||
|  |         } | ||||||
|  |  | ||||||
|         if (ready_to_run) { |         if (ready_to_run) { | ||||||
|             candidate = thread.get(); |             candidate = thread.get(); | ||||||
|             candidate_priority = thread->current_priority; |             candidate_priority = thread->current_priority; | ||||||
| @@ -66,7 +72,7 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() { | |||||||
| void WaitObject::WakeupAllWaitingThreads() { | void WaitObject::WakeupAllWaitingThreads() { | ||||||
|     while (auto thread = GetHighestPriorityReadyThread()) { |     while (auto thread = GetHighestPriorityReadyThread()) { | ||||||
|         if (!thread->IsSleepingOnWaitAll()) { |         if (!thread->IsSleepingOnWaitAll()) { | ||||||
|             Acquire(); |             Acquire(thread.get()); | ||||||
|             // Set the output index of the WaitSynchronizationN call to the index of this object. |             // Set the output index of the WaitSynchronizationN call to the index of this object. | ||||||
|             if (thread->wait_set_output) { |             if (thread->wait_set_output) { | ||||||
|                 thread->SetWaitSynchronizationOutput(thread->GetWaitObjectIndex(this)); |                 thread->SetWaitSynchronizationOutput(thread->GetWaitObjectIndex(this)); | ||||||
| @@ -74,18 +80,17 @@ void WaitObject::WakeupAllWaitingThreads() { | |||||||
|             } |             } | ||||||
|         } else { |         } else { | ||||||
|             for (auto& object : thread->wait_objects) { |             for (auto& object : thread->wait_objects) { | ||||||
|                 object->Acquire(); |                 object->Acquire(thread.get()); | ||||||
|                 object->RemoveWaitingThread(thread.get()); |  | ||||||
|             } |             } | ||||||
|             // Note: This case doesn't update the output index of WaitSynchronizationN. |             // Note: This case doesn't update the output index of WaitSynchronizationN. | ||||||
|             // Clear the thread's waitlist |  | ||||||
|             thread->wait_objects.clear(); |  | ||||||
|         } |         } | ||||||
|  |  | ||||||
|  |         for (auto& object : thread->wait_objects) | ||||||
|  |             object->RemoveWaitingThread(thread.get()); | ||||||
|  |         thread->wait_objects.clear(); | ||||||
|  |  | ||||||
|         thread->SetWaitSynchronizationResult(RESULT_SUCCESS); |         thread->SetWaitSynchronizationResult(RESULT_SUCCESS); | ||||||
|         thread->ResumeFromWait(); |         thread->ResumeFromWait(); | ||||||
|         // Note: Removing the thread from the object's waitlist will be |  | ||||||
|         // done by GetHighestPriorityReadyThread. |  | ||||||
|     } |     } | ||||||
| } | } | ||||||
|  |  | ||||||
|   | |||||||
| @@ -132,25 +132,26 @@ using SharedPtr = boost::intrusive_ptr<T>; | |||||||
| class WaitObject : public Object { | class WaitObject : public Object { | ||||||
| public: | public: | ||||||
|     /** |     /** | ||||||
|      * Check if the current thread should wait until the object is available |      * Check if the specified thread should wait until the object is available | ||||||
|  |      * @param thread The thread about which we're deciding. | ||||||
|      * @return True if the current thread should wait due to this object being unavailable |      * @return True if the current thread should wait due to this object being unavailable | ||||||
|      */ |      */ | ||||||
|     virtual bool ShouldWait() = 0; |     virtual bool ShouldWait(Thread* thread) const = 0; | ||||||
|  |  | ||||||
|     /// Acquire/lock the object if it is available |     /// Acquire/lock the object for the specified thread if it is available | ||||||
|     virtual void Acquire() = 0; |     virtual void Acquire(Thread* thread) = 0; | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Add a thread to wait on this object |      * Add a thread to wait on this object | ||||||
|      * @param thread Pointer to thread to add |      * @param thread Pointer to thread to add | ||||||
|      */ |      */ | ||||||
|     void AddWaitingThread(SharedPtr<Thread> thread); |     virtual void AddWaitingThread(SharedPtr<Thread> thread); | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Removes a thread from waiting on this object (e.g. if it was resumed already) |      * Removes a thread from waiting on this object (e.g. if it was resumed already) | ||||||
|      * @param thread Pointer to thread to remove |      * @param thread Pointer to thread to remove | ||||||
|      */ |      */ | ||||||
|     void RemoveWaitingThread(Thread* thread); |     virtual void RemoveWaitingThread(Thread* thread); | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Wake up all threads waiting on this object that can be awoken, in priority order, |      * Wake up all threads waiting on this object that can be awoken, in priority order, | ||||||
|   | |||||||
| @@ -6,26 +6,18 @@ | |||||||
| #include <vector> | #include <vector> | ||||||
| #include <boost/range/algorithm_ext/erase.hpp> | #include <boost/range/algorithm_ext/erase.hpp> | ||||||
| #include "common/assert.h" | #include "common/assert.h" | ||||||
|  | #include "core/core.h" | ||||||
| #include "core/hle/kernel/kernel.h" | #include "core/hle/kernel/kernel.h" | ||||||
| #include "core/hle/kernel/mutex.h" | #include "core/hle/kernel/mutex.h" | ||||||
| #include "core/hle/kernel/thread.h" | #include "core/hle/kernel/thread.h" | ||||||
|  |  | ||||||
| namespace Kernel { | namespace Kernel { | ||||||
|  |  | ||||||
| /** |  | ||||||
|  * Resumes a thread waiting for the specified mutex |  | ||||||
|  * @param mutex The mutex that some thread is waiting on |  | ||||||
|  */ |  | ||||||
| static void ResumeWaitingThread(Mutex* mutex) { |  | ||||||
|     // Reset mutex lock thread handle, nothing is waiting |  | ||||||
|     mutex->lock_count = 0; |  | ||||||
|     mutex->holding_thread = nullptr; |  | ||||||
|     mutex->WakeupAllWaitingThreads(); |  | ||||||
| } |  | ||||||
|  |  | ||||||
| void ReleaseThreadMutexes(Thread* thread) { | void ReleaseThreadMutexes(Thread* thread) { | ||||||
|     for (auto& mtx : thread->held_mutexes) { |     for (auto& mtx : thread->held_mutexes) { | ||||||
|         ResumeWaitingThread(mtx.get()); |         mtx->lock_count = 0; | ||||||
|  |         mtx->holding_thread = nullptr; | ||||||
|  |         mtx->WakeupAllWaitingThreads(); | ||||||
|     } |     } | ||||||
|     thread->held_mutexes.clear(); |     thread->held_mutexes.clear(); | ||||||
| } | } | ||||||
| @@ -40,52 +32,74 @@ SharedPtr<Mutex> Mutex::Create(bool initial_locked, std::string name) { | |||||||
|     mutex->name = std::move(name); |     mutex->name = std::move(name); | ||||||
|     mutex->holding_thread = nullptr; |     mutex->holding_thread = nullptr; | ||||||
|  |  | ||||||
|     // Acquire mutex with current thread if initialized as locked... |     // Acquire mutex with current thread if initialized as locked | ||||||
|     if (initial_locked) |     if (initial_locked) | ||||||
|         mutex->Acquire(); |         mutex->Acquire(GetCurrentThread()); | ||||||
|  |  | ||||||
|     return mutex; |     return mutex; | ||||||
| } | } | ||||||
|  |  | ||||||
| bool Mutex::ShouldWait() { | bool Mutex::ShouldWait(Thread* thread) const { | ||||||
|     auto thread = GetCurrentThread(); |     return lock_count > 0 && thread != holding_thread; | ||||||
|     bool wait = lock_count > 0 && holding_thread != thread; |  | ||||||
|  |  | ||||||
|     // If the holding thread of the mutex is lower priority than this thread, that thread should |  | ||||||
|     // temporarily inherit this thread's priority |  | ||||||
|     if (wait && thread->current_priority < holding_thread->current_priority) |  | ||||||
|         holding_thread->BoostPriority(thread->current_priority); |  | ||||||
|  |  | ||||||
|     return wait; |  | ||||||
| } | } | ||||||
|  |  | ||||||
| void Mutex::Acquire() { | void Mutex::Acquire(Thread* thread) { | ||||||
|     Acquire(GetCurrentThread()); |     ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); | ||||||
| } |  | ||||||
|  |  | ||||||
| void Mutex::Acquire(SharedPtr<Thread> thread) { |     // Actually "acquire" the mutex only if we don't already have it | ||||||
|     ASSERT_MSG(!ShouldWait(), "object unavailable!"); |  | ||||||
|  |  | ||||||
|     // Actually "acquire" the mutex only if we don't already have it... |  | ||||||
|     if (lock_count == 0) { |     if (lock_count == 0) { | ||||||
|  |         priority = thread->current_priority; | ||||||
|         thread->held_mutexes.insert(this); |         thread->held_mutexes.insert(this); | ||||||
|         holding_thread = std::move(thread); |         holding_thread = thread; | ||||||
|  |         thread->UpdatePriority(); | ||||||
|  |         Core::System::GetInstance().PrepareReschedule(); | ||||||
|     } |     } | ||||||
|  |  | ||||||
|     lock_count++; |     lock_count++; | ||||||
| } | } | ||||||
|  |  | ||||||
| void Mutex::Release() { | void Mutex::Release() { | ||||||
|     // Only release if the mutex is held... |     // Only release if the mutex is held | ||||||
|     if (lock_count > 0) { |     if (lock_count > 0) { | ||||||
|         lock_count--; |         lock_count--; | ||||||
|  |  | ||||||
|         // Yield to the next thread only if we've fully released the mutex... |         // Yield to the next thread only if we've fully released the mutex | ||||||
|         if (lock_count == 0) { |         if (lock_count == 0) { | ||||||
|             holding_thread->held_mutexes.erase(this); |             holding_thread->held_mutexes.erase(this); | ||||||
|             ResumeWaitingThread(this); |             holding_thread->UpdatePriority(); | ||||||
|  |             holding_thread = nullptr; | ||||||
|  |             WakeupAllWaitingThreads(); | ||||||
|  |             Core::System::GetInstance().PrepareReschedule(); | ||||||
|         } |         } | ||||||
|     } |     } | ||||||
| } | } | ||||||
|  |  | ||||||
|  | void Mutex::AddWaitingThread(SharedPtr<Thread> thread) { | ||||||
|  |     WaitObject::AddWaitingThread(thread); | ||||||
|  |     thread->pending_mutexes.insert(this); | ||||||
|  |     UpdatePriority(); | ||||||
|  | } | ||||||
|  |  | ||||||
|  | void Mutex::RemoveWaitingThread(Thread* thread) { | ||||||
|  |     WaitObject::RemoveWaitingThread(thread); | ||||||
|  |     thread->pending_mutexes.erase(this); | ||||||
|  |     UpdatePriority(); | ||||||
|  | } | ||||||
|  |  | ||||||
|  | void Mutex::UpdatePriority() { | ||||||
|  |     if (!holding_thread) | ||||||
|  |         return; | ||||||
|  |  | ||||||
|  |     s32 best_priority = THREADPRIO_LOWEST; | ||||||
|  |     for (auto& waiter : GetWaitingThreads()) { | ||||||
|  |         if (waiter->current_priority < best_priority) | ||||||
|  |             best_priority = waiter->current_priority; | ||||||
|  |     } | ||||||
|  |  | ||||||
|  |     if (best_priority != priority) { | ||||||
|  |         priority = best_priority; | ||||||
|  |         holding_thread->UpdatePriority(); | ||||||
|  |     } | ||||||
|  | } | ||||||
|  |  | ||||||
| } // namespace | } // namespace | ||||||
|   | |||||||
| @@ -35,17 +35,22 @@ public: | |||||||
|     } |     } | ||||||
|  |  | ||||||
|     int lock_count;                   ///< Number of times the mutex has been acquired |     int lock_count;                   ///< Number of times the mutex has been acquired | ||||||
|  |     u32 priority;                     ///< The priority of the mutex, used for priority inheritance. | ||||||
|     std::string name;                 ///< Name of mutex (optional) |     std::string name;                 ///< Name of mutex (optional) | ||||||
|     SharedPtr<Thread> holding_thread; ///< Thread that has acquired the mutex |     SharedPtr<Thread> holding_thread; ///< Thread that has acquired the mutex | ||||||
|  |  | ||||||
|     bool ShouldWait() override; |  | ||||||
|     void Acquire() override; |  | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Acquires the specified mutex for the specified thread |      * Elevate the mutex priority to the best priority | ||||||
|      * @param thread Thread that will acquire the mutex |      * among the priorities of all its waiting threads. | ||||||
|      */ |      */ | ||||||
|     void Acquire(SharedPtr<Thread> thread); |     void UpdatePriority(); | ||||||
|  |  | ||||||
|  |     bool ShouldWait(Thread* thread) const override; | ||||||
|  |     void Acquire(Thread* thread) override; | ||||||
|  |  | ||||||
|  |     void AddWaitingThread(SharedPtr<Thread> thread) override; | ||||||
|  |     void RemoveWaitingThread(Thread* thread) override; | ||||||
|  |  | ||||||
|     void Release(); |     void Release(); | ||||||
|  |  | ||||||
| private: | private: | ||||||
|   | |||||||
| @@ -30,12 +30,12 @@ ResultVal<SharedPtr<Semaphore>> Semaphore::Create(s32 initial_count, s32 max_cou | |||||||
|     return MakeResult<SharedPtr<Semaphore>>(std::move(semaphore)); |     return MakeResult<SharedPtr<Semaphore>>(std::move(semaphore)); | ||||||
| } | } | ||||||
|  |  | ||||||
| bool Semaphore::ShouldWait() { | bool Semaphore::ShouldWait(Thread* thread) const { | ||||||
|     return available_count <= 0; |     return available_count <= 0; | ||||||
| } | } | ||||||
|  |  | ||||||
| void Semaphore::Acquire() { | void Semaphore::Acquire(Thread* thread) { | ||||||
|     ASSERT_MSG(!ShouldWait(), "object unavailable!"); |     ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); | ||||||
|     --available_count; |     --available_count; | ||||||
| } | } | ||||||
|  |  | ||||||
|   | |||||||
| @@ -39,8 +39,8 @@ public: | |||||||
|     s32 available_count; ///< Number of free slots left in the semaphore |     s32 available_count; ///< Number of free slots left in the semaphore | ||||||
|     std::string name;    ///< Name of semaphore (optional) |     std::string name;    ///< Name of semaphore (optional) | ||||||
|  |  | ||||||
|     bool ShouldWait() override; |     bool ShouldWait(Thread* thread) const override; | ||||||
|     void Acquire() override; |     void Acquire(Thread* thread) override; | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Releases a certain number of slots from a semaphore. |      * Releases a certain number of slots from a semaphore. | ||||||
|   | |||||||
| @@ -14,13 +14,13 @@ namespace Kernel { | |||||||
| ServerPort::ServerPort() {} | ServerPort::ServerPort() {} | ||||||
| ServerPort::~ServerPort() {} | ServerPort::~ServerPort() {} | ||||||
|  |  | ||||||
| bool ServerPort::ShouldWait() { | bool ServerPort::ShouldWait(Thread* thread) const { | ||||||
|     // If there are no pending sessions, we wait until a new one is added. |     // If there are no pending sessions, we wait until a new one is added. | ||||||
|     return pending_sessions.size() == 0; |     return pending_sessions.size() == 0; | ||||||
| } | } | ||||||
|  |  | ||||||
| void ServerPort::Acquire() { | void ServerPort::Acquire(Thread* thread) { | ||||||
|     ASSERT_MSG(!ShouldWait(), "object unavailable!"); |     ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); | ||||||
| } | } | ||||||
|  |  | ||||||
| std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair( | std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair( | ||||||
|   | |||||||
| @@ -53,8 +53,8 @@ public: | |||||||
|     /// ServerSessions created from this port inherit a reference to this handler. |     /// ServerSessions created from this port inherit a reference to this handler. | ||||||
|     std::shared_ptr<Service::SessionRequestHandler> hle_handler; |     std::shared_ptr<Service::SessionRequestHandler> hle_handler; | ||||||
|  |  | ||||||
|     bool ShouldWait() override; |     bool ShouldWait(Thread* thread) const override; | ||||||
|     void Acquire() override; |     void Acquire(Thread* thread) override; | ||||||
|  |  | ||||||
| private: | private: | ||||||
|     ServerPort(); |     ServerPort(); | ||||||
|   | |||||||
| @@ -29,12 +29,12 @@ ResultVal<SharedPtr<ServerSession>> ServerSession::Create( | |||||||
|     return MakeResult<SharedPtr<ServerSession>>(std::move(server_session)); |     return MakeResult<SharedPtr<ServerSession>>(std::move(server_session)); | ||||||
| } | } | ||||||
|  |  | ||||||
| bool ServerSession::ShouldWait() { | bool ServerSession::ShouldWait(Thread* thread) const { | ||||||
|     return !signaled; |     return !signaled; | ||||||
| } | } | ||||||
|  |  | ||||||
| void ServerSession::Acquire() { | void ServerSession::Acquire(Thread* thread) { | ||||||
|     ASSERT_MSG(!ShouldWait(), "object unavailable!"); |     ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); | ||||||
|     signaled = false; |     signaled = false; | ||||||
| } | } | ||||||
|  |  | ||||||
|   | |||||||
| @@ -57,9 +57,9 @@ public: | |||||||
|      */ |      */ | ||||||
|     ResultCode HandleSyncRequest(); |     ResultCode HandleSyncRequest(); | ||||||
|  |  | ||||||
|     bool ShouldWait() override; |     bool ShouldWait(Thread* thread) const override; | ||||||
|  |  | ||||||
|     void Acquire() override; |     void Acquire(Thread* thread) override; | ||||||
|  |  | ||||||
|     std::string name; ///< The name of this session (optional) |     std::string name; ///< The name of this session (optional) | ||||||
|     bool signaled;    ///< Whether there's new data available to this ServerSession |     bool signaled;    ///< Whether there's new data available to this ServerSession | ||||||
|   | |||||||
| @@ -27,12 +27,12 @@ namespace Kernel { | |||||||
| /// Event type for the thread wake up event | /// Event type for the thread wake up event | ||||||
| static int ThreadWakeupEventType; | static int ThreadWakeupEventType; | ||||||
|  |  | ||||||
| bool Thread::ShouldWait() { | bool Thread::ShouldWait(Thread* thread) const { | ||||||
|     return status != THREADSTATUS_DEAD; |     return status != THREADSTATUS_DEAD; | ||||||
| } | } | ||||||
|  |  | ||||||
| void Thread::Acquire() { | void Thread::Acquire(Thread* thread) { | ||||||
|     ASSERT_MSG(!ShouldWait(), "object unavailable!"); |     ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); | ||||||
| } | } | ||||||
|  |  | ||||||
| // TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future, allowing | // TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future, allowing | ||||||
| @@ -72,7 +72,8 @@ Thread* GetCurrentThread() { | |||||||
|  * @return True if the thread is waiting, false otherwise |  * @return True if the thread is waiting, false otherwise | ||||||
|  */ |  */ | ||||||
| static bool CheckWait_WaitObject(const Thread* thread, WaitObject* wait_object) { | static bool CheckWait_WaitObject(const Thread* thread, WaitObject* wait_object) { | ||||||
|     if (thread->status != THREADSTATUS_WAIT_SYNCH) |     if (thread->status != THREADSTATUS_WAIT_SYNCH_ALL && | ||||||
|  |         thread->status != THREADSTATUS_WAIT_SYNCH_ANY) | ||||||
|         return false; |         return false; | ||||||
|  |  | ||||||
|     auto itr = std::find(thread->wait_objects.begin(), thread->wait_objects.end(), wait_object); |     auto itr = std::find(thread->wait_objects.begin(), thread->wait_objects.end(), wait_object); | ||||||
| @@ -90,9 +91,6 @@ static bool CheckWait_AddressArbiter(const Thread* thread, VAddr wait_address) { | |||||||
| } | } | ||||||
|  |  | ||||||
| void Thread::Stop() { | void Thread::Stop() { | ||||||
|     // Release all the mutexes that this thread holds |  | ||||||
|     ReleaseThreadMutexes(this); |  | ||||||
|  |  | ||||||
|     // Cancel any outstanding wakeup events for this thread |     // Cancel any outstanding wakeup events for this thread | ||||||
|     CoreTiming::UnscheduleEvent(ThreadWakeupEventType, callback_handle); |     CoreTiming::UnscheduleEvent(ThreadWakeupEventType, callback_handle); | ||||||
|     wakeup_callback_handle_table.Close(callback_handle); |     wakeup_callback_handle_table.Close(callback_handle); | ||||||
| @@ -114,6 +112,9 @@ void Thread::Stop() { | |||||||
|     } |     } | ||||||
|     wait_objects.clear(); |     wait_objects.clear(); | ||||||
|  |  | ||||||
|  |     // Release all the mutexes that this thread holds | ||||||
|  |     ReleaseThreadMutexes(this); | ||||||
|  |  | ||||||
|     // Mark the TLS slot in the thread's page as free. |     // Mark the TLS slot in the thread's page as free. | ||||||
|     u32 tls_page = (tls_address - Memory::TLS_AREA_VADDR) / Memory::PAGE_SIZE; |     u32 tls_page = (tls_address - Memory::TLS_AREA_VADDR) / Memory::PAGE_SIZE; | ||||||
|     u32 tls_slot = |     u32 tls_slot = | ||||||
| @@ -199,8 +200,8 @@ static void SwitchContext(Thread* new_thread) { | |||||||
|  |  | ||||||
|     // Load context of new thread |     // Load context of new thread | ||||||
|     if (new_thread) { |     if (new_thread) { | ||||||
|         DEBUG_ASSERT_MSG(new_thread->status == THREADSTATUS_READY, |         ASSERT_MSG(new_thread->status == THREADSTATUS_READY, | ||||||
|                          "Thread must be ready to become running."); |                    "Thread must be ready to become running."); | ||||||
|  |  | ||||||
|         // Cancel any outstanding wakeup events for this thread |         // Cancel any outstanding wakeup events for this thread | ||||||
|         CoreTiming::UnscheduleEvent(ThreadWakeupEventType, new_thread->callback_handle); |         CoreTiming::UnscheduleEvent(ThreadWakeupEventType, new_thread->callback_handle); | ||||||
| @@ -253,7 +254,7 @@ void WaitCurrentThread_WaitSynchronization(std::vector<SharedPtr<WaitObject>> wa | |||||||
|     Thread* thread = GetCurrentThread(); |     Thread* thread = GetCurrentThread(); | ||||||
|     thread->wait_set_output = wait_set_output; |     thread->wait_set_output = wait_set_output; | ||||||
|     thread->wait_objects = std::move(wait_objects); |     thread->wait_objects = std::move(wait_objects); | ||||||
|     thread->status = THREADSTATUS_WAIT_SYNCH; |     thread->status = THREADSTATUS_WAIT_SYNCH_ANY; | ||||||
| } | } | ||||||
|  |  | ||||||
| void WaitCurrentThread_ArbitrateAddress(VAddr wait_address) { | void WaitCurrentThread_ArbitrateAddress(VAddr wait_address) { | ||||||
| @@ -281,7 +282,8 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) { | |||||||
|         return; |         return; | ||||||
|     } |     } | ||||||
|  |  | ||||||
|     if (thread->status == THREADSTATUS_WAIT_SYNCH || thread->status == THREADSTATUS_WAIT_ARB) { |     if (thread->status == THREADSTATUS_WAIT_SYNCH_ANY || | ||||||
|  |         thread->status == THREADSTATUS_WAIT_SYNCH_ALL || thread->status == THREADSTATUS_WAIT_ARB) { | ||||||
|         thread->wait_set_output = false; |         thread->wait_set_output = false; | ||||||
|         // Remove the thread from each of its waiting objects' waitlists |         // Remove the thread from each of its waiting objects' waitlists | ||||||
|         for (auto& object : thread->wait_objects) |         for (auto& object : thread->wait_objects) | ||||||
| @@ -305,8 +307,11 @@ void Thread::WakeAfterDelay(s64 nanoseconds) { | |||||||
| } | } | ||||||
|  |  | ||||||
| void Thread::ResumeFromWait() { | void Thread::ResumeFromWait() { | ||||||
|  |     ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects"); | ||||||
|  |  | ||||||
|     switch (status) { |     switch (status) { | ||||||
|     case THREADSTATUS_WAIT_SYNCH: |     case THREADSTATUS_WAIT_SYNCH_ALL: | ||||||
|  |     case THREADSTATUS_WAIT_SYNCH_ANY: | ||||||
|     case THREADSTATUS_WAIT_ARB: |     case THREADSTATUS_WAIT_ARB: | ||||||
|     case THREADSTATUS_WAIT_SLEEP: |     case THREADSTATUS_WAIT_SLEEP: | ||||||
|         break; |         break; | ||||||
| @@ -515,8 +520,21 @@ void Thread::SetPriority(s32 priority) { | |||||||
|     nominal_priority = current_priority = priority; |     nominal_priority = current_priority = priority; | ||||||
| } | } | ||||||
|  |  | ||||||
|  | void Thread::UpdatePriority() { | ||||||
|  |     s32 best_priority = nominal_priority; | ||||||
|  |     for (auto& mutex : held_mutexes) { | ||||||
|  |         if (mutex->priority < best_priority) | ||||||
|  |             best_priority = mutex->priority; | ||||||
|  |     } | ||||||
|  |     BoostPriority(best_priority); | ||||||
|  | } | ||||||
|  |  | ||||||
| void Thread::BoostPriority(s32 priority) { | void Thread::BoostPriority(s32 priority) { | ||||||
|     ready_queue.move(this, current_priority, priority); |     // If thread was ready, adjust queues | ||||||
|  |     if (status == THREADSTATUS_READY) | ||||||
|  |         ready_queue.move(this, current_priority, priority); | ||||||
|  |     else | ||||||
|  |         ready_queue.prepare(priority); | ||||||
|     current_priority = priority; |     current_priority = priority; | ||||||
| } | } | ||||||
|  |  | ||||||
| @@ -563,6 +581,12 @@ void Thread::SetWaitSynchronizationOutput(s32 output) { | |||||||
|     context.cpu_registers[1] = output; |     context.cpu_registers[1] = output; | ||||||
| } | } | ||||||
|  |  | ||||||
|  | s32 Thread::GetWaitObjectIndex(WaitObject* object) const { | ||||||
|  |     ASSERT_MSG(!wait_objects.empty(), "Thread is not waiting for anything"); | ||||||
|  |     auto match = std::find(wait_objects.rbegin(), wait_objects.rend(), object); | ||||||
|  |     return std::distance(match, wait_objects.rend()) - 1; | ||||||
|  | } | ||||||
|  |  | ||||||
| //////////////////////////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////////////////////////// | ||||||
|  |  | ||||||
| void ThreadingInit() { | void ThreadingInit() { | ||||||
|   | |||||||
| @@ -31,13 +31,14 @@ enum ThreadProcessorId : s32 { | |||||||
| }; | }; | ||||||
|  |  | ||||||
| enum ThreadStatus { | enum ThreadStatus { | ||||||
|     THREADSTATUS_RUNNING,    ///< Currently running |     THREADSTATUS_RUNNING,        ///< Currently running | ||||||
|     THREADSTATUS_READY,      ///< Ready to run |     THREADSTATUS_READY,          ///< Ready to run | ||||||
|     THREADSTATUS_WAIT_ARB,   ///< Waiting on an address arbiter |     THREADSTATUS_WAIT_ARB,       ///< Waiting on an address arbiter | ||||||
|     THREADSTATUS_WAIT_SLEEP, ///< Waiting due to a SleepThread SVC |     THREADSTATUS_WAIT_SLEEP,     ///< Waiting due to a SleepThread SVC | ||||||
|     THREADSTATUS_WAIT_SYNCH, ///< Waiting due to a WaitSynchronization SVC |     THREADSTATUS_WAIT_SYNCH_ANY, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false | ||||||
|     THREADSTATUS_DORMANT,    ///< Created but not yet made ready |     THREADSTATUS_WAIT_SYNCH_ALL, ///< Waiting due to WaitSynchronizationN with wait_all = true | ||||||
|     THREADSTATUS_DEAD        ///< Run to completion, or forcefully terminated |     THREADSTATUS_DORMANT,        ///< Created but not yet made ready | ||||||
|  |     THREADSTATUS_DEAD            ///< Run to completion, or forcefully terminated | ||||||
| }; | }; | ||||||
|  |  | ||||||
| namespace Kernel { | namespace Kernel { | ||||||
| @@ -72,8 +73,8 @@ public: | |||||||
|         return HANDLE_TYPE; |         return HANDLE_TYPE; | ||||||
|     } |     } | ||||||
|  |  | ||||||
|     bool ShouldWait() override; |     bool ShouldWait(Thread* thread) const override; | ||||||
|     void Acquire() override; |     void Acquire(Thread* thread) override; | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Gets the thread's current priority |      * Gets the thread's current priority | ||||||
| @@ -89,6 +90,12 @@ public: | |||||||
|      */ |      */ | ||||||
|     void SetPriority(s32 priority); |     void SetPriority(s32 priority); | ||||||
|  |  | ||||||
|  |     /** | ||||||
|  |      * Boost's a thread's priority to the best priority among the thread's held mutexes. | ||||||
|  |      * This prevents priority inversion via priority inheritance. | ||||||
|  |      */ | ||||||
|  |     void UpdatePriority(); | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Temporarily boosts the thread's priority until the next time it is scheduled |      * Temporarily boosts the thread's priority until the next time it is scheduled | ||||||
|      * @param priority The new priority |      * @param priority The new priority | ||||||
| @@ -128,13 +135,14 @@ public: | |||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Retrieves the index that this particular object occupies in the list of objects |      * Retrieves the index that this particular object occupies in the list of objects | ||||||
|      * that the thread passed to WaitSynchronizationN. |      * that the thread passed to WaitSynchronizationN, starting the search from the last element. | ||||||
|      * It is used to set the output value of WaitSynchronizationN when the thread is awakened. |      * It is used to set the output value of WaitSynchronizationN when the thread is awakened. | ||||||
|  |      * When a thread wakes up due to an object signal, the kernel will use the index of the last | ||||||
|  |      * matching object in the wait objects list in case of having multiple instances of the same | ||||||
|  |      * object in the list. | ||||||
|      * @param object Object to query the index of. |      * @param object Object to query the index of. | ||||||
|      */ |      */ | ||||||
|     s32 GetWaitObjectIndex(const WaitObject* object) const { |     s32 GetWaitObjectIndex(WaitObject* object) const; | ||||||
|         return wait_objects_index.at(object->GetObjectId()); |  | ||||||
|     } |  | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Stops a thread, invalidating it from further use |      * Stops a thread, invalidating it from further use | ||||||
| @@ -152,10 +160,10 @@ public: | |||||||
|     /** |     /** | ||||||
|      * Returns whether this thread is waiting for all the objects in |      * Returns whether this thread is waiting for all the objects in | ||||||
|      * its wait list to become ready, as a result of a WaitSynchronizationN call |      * its wait list to become ready, as a result of a WaitSynchronizationN call | ||||||
|      * with wait_all = true, or a ReplyAndReceive call. |      * with wait_all = true. | ||||||
|      */ |      */ | ||||||
|     bool IsSleepingOnWaitAll() const { |     bool IsSleepingOnWaitAll() const { | ||||||
|         return !wait_objects.empty(); |         return status == THREADSTATUS_WAIT_SYNCH_ALL; | ||||||
|     } |     } | ||||||
|  |  | ||||||
|     ARM_Interface::ThreadContext context; |     ARM_Interface::ThreadContext context; | ||||||
| @@ -178,15 +186,15 @@ public: | |||||||
|     /// Mutexes currently held by this thread, which will be released when it exits. |     /// Mutexes currently held by this thread, which will be released when it exits. | ||||||
|     boost::container::flat_set<SharedPtr<Mutex>> held_mutexes; |     boost::container::flat_set<SharedPtr<Mutex>> held_mutexes; | ||||||
|  |  | ||||||
|  |     /// Mutexes that this thread is currently waiting for. | ||||||
|  |     boost::container::flat_set<SharedPtr<Mutex>> pending_mutexes; | ||||||
|  |  | ||||||
|     SharedPtr<Process> owner_process; ///< Process that owns this thread |     SharedPtr<Process> owner_process; ///< Process that owns this thread | ||||||
|  |  | ||||||
|     /// Objects that the thread is waiting on. |     /// Objects that the thread is waiting on, in the same order as they were | ||||||
|     /// This is only populated when the thread should wait for all the objects to become ready. |     // passed to WaitSynchronization1/N. | ||||||
|     std::vector<SharedPtr<WaitObject>> wait_objects; |     std::vector<SharedPtr<WaitObject>> wait_objects; | ||||||
|  |  | ||||||
|     /// Mapping of Object ids to their position in the last waitlist that this object waited on. |  | ||||||
|     boost::container::flat_map<int, s32> wait_objects_index; |  | ||||||
|  |  | ||||||
|     VAddr wait_address; ///< If waiting on an AddressArbiter, this is the arbitration address |     VAddr wait_address; ///< If waiting on an AddressArbiter, this is the arbitration address | ||||||
|  |  | ||||||
|     /// True if the WaitSynchronizationN output parameter should be set on thread wakeup. |     /// True if the WaitSynchronizationN output parameter should be set on thread wakeup. | ||||||
|   | |||||||
| @@ -39,12 +39,12 @@ SharedPtr<Timer> Timer::Create(ResetType reset_type, std::string name) { | |||||||
|     return timer; |     return timer; | ||||||
| } | } | ||||||
|  |  | ||||||
| bool Timer::ShouldWait() { | bool Timer::ShouldWait(Thread* thread) const { | ||||||
|     return !signaled; |     return !signaled; | ||||||
| } | } | ||||||
|  |  | ||||||
| void Timer::Acquire() { | void Timer::Acquire(Thread* thread) { | ||||||
|     ASSERT_MSG(!ShouldWait(), "object unavailable!"); |     ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); | ||||||
|  |  | ||||||
|     if (reset_type == ResetType::OneShot) |     if (reset_type == ResetType::OneShot) | ||||||
|         signaled = false; |         signaled = false; | ||||||
|   | |||||||
| @@ -39,8 +39,8 @@ public: | |||||||
|     u64 initial_delay;  ///< The delay until the timer fires for the first time |     u64 initial_delay;  ///< The delay until the timer fires for the first time | ||||||
|     u64 interval_delay; ///< The delay until the timer fires after the first time |     u64 interval_delay; ///< The delay until the timer fires after the first time | ||||||
|  |  | ||||||
|     bool ShouldWait() override; |     bool ShouldWait(Thread* thread) const override; | ||||||
|     void Acquire() override; |     void Acquire(Thread* thread) override; | ||||||
|  |  | ||||||
|     /** |     /** | ||||||
|      * Starts the timer, with the specified initial delay and interval. |      * Starts the timer, with the specified initial delay and interval. | ||||||
|   | |||||||
| @@ -248,6 +248,8 @@ static ResultCode SendSyncRequest(Kernel::Handle handle) { | |||||||
|  |  | ||||||
|     LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s)", handle, session->GetName().c_str()); |     LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s)", handle, session->GetName().c_str()); | ||||||
|  |  | ||||||
|  |     Core::System::GetInstance().PrepareReschedule(); | ||||||
|  |  | ||||||
|     // TODO(Subv): svcSendSyncRequest should put the caller thread to sleep while the server |     // TODO(Subv): svcSendSyncRequest should put the caller thread to sleep while the server | ||||||
|     // responds and cause a reschedule. |     // responds and cause a reschedule. | ||||||
|     return session->SendSyncRequest(); |     return session->SendSyncRequest(); | ||||||
| @@ -270,27 +272,27 @@ static ResultCode WaitSynchronization1(Kernel::Handle handle, s64 nano_seconds) | |||||||
|     LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s:%s), nanoseconds=%lld", handle, |     LOG_TRACE(Kernel_SVC, "called handle=0x%08X(%s:%s), nanoseconds=%lld", handle, | ||||||
|               object->GetTypeName().c_str(), object->GetName().c_str(), nano_seconds); |               object->GetTypeName().c_str(), object->GetName().c_str(), nano_seconds); | ||||||
|  |  | ||||||
|     if (object->ShouldWait()) { |     if (object->ShouldWait(thread)) { | ||||||
|  |  | ||||||
|         if (nano_seconds == 0) |         if (nano_seconds == 0) | ||||||
|             return ERR_SYNC_TIMEOUT; |             return ERR_SYNC_TIMEOUT; | ||||||
|  |  | ||||||
|  |         thread->wait_objects = {object}; | ||||||
|         object->AddWaitingThread(thread); |         object->AddWaitingThread(thread); | ||||||
|         // TODO(Subv): Perform things like update the mutex lock owner's priority to |         thread->status = THREADSTATUS_WAIT_SYNCH_ANY; | ||||||
|         // prevent priority inversion. Currently this is done in Mutex::ShouldWait, |  | ||||||
|         // but it should be moved to a function that is called from here. |  | ||||||
|         thread->status = THREADSTATUS_WAIT_SYNCH; |  | ||||||
|  |  | ||||||
|         // Create an event to wake the thread up after the specified nanosecond delay has passed |         // Create an event to wake the thread up after the specified nanosecond delay has passed | ||||||
|         thread->WakeAfterDelay(nano_seconds); |         thread->WakeAfterDelay(nano_seconds); | ||||||
|  |  | ||||||
|  |         Core::System::GetInstance().PrepareReschedule(); | ||||||
|  |  | ||||||
|         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread |         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread | ||||||
|         // resumes due to a signal in its wait objects. |         // resumes due to a signal in its wait objects. | ||||||
|         // Otherwise we retain the default value of timeout. |         // Otherwise we retain the default value of timeout. | ||||||
|         return ERR_SYNC_TIMEOUT; |         return ERR_SYNC_TIMEOUT; | ||||||
|     } |     } | ||||||
|  |  | ||||||
|     object->Acquire(); |     object->Acquire(thread); | ||||||
|  |  | ||||||
|     return RESULT_SUCCESS; |     return RESULT_SUCCESS; | ||||||
| } | } | ||||||
| @@ -324,19 +326,14 @@ static ResultCode WaitSynchronizationN(s32* out, Kernel::Handle* handles, s32 ha | |||||||
|         objects[i] = object; |         objects[i] = object; | ||||||
|     } |     } | ||||||
|  |  | ||||||
|     // Clear the mapping of wait object indices. |  | ||||||
|     // We don't want any lingering state in this map. |  | ||||||
|     // It will be repopulated later in the wait_all = false case. |  | ||||||
|     thread->wait_objects_index.clear(); |  | ||||||
|  |  | ||||||
|     if (wait_all) { |     if (wait_all) { | ||||||
|         bool all_available = |         bool all_available = | ||||||
|             std::all_of(objects.begin(), objects.end(), |             std::all_of(objects.begin(), objects.end(), | ||||||
|                         [](const ObjectPtr& object) { return !object->ShouldWait(); }); |                         [thread](const ObjectPtr& object) { return !object->ShouldWait(thread); }); | ||||||
|         if (all_available) { |         if (all_available) { | ||||||
|             // We can acquire all objects right now, do so. |             // We can acquire all objects right now, do so. | ||||||
|             for (auto& object : objects) |             for (auto& object : objects) | ||||||
|                 object->Acquire(); |                 object->Acquire(thread); | ||||||
|             // Note: In this case, the `out` parameter is not set, |             // Note: In this case, the `out` parameter is not set, | ||||||
|             // and retains whatever value it had before. |             // and retains whatever value it had before. | ||||||
|             return RESULT_SUCCESS; |             return RESULT_SUCCESS; | ||||||
| @@ -350,22 +347,20 @@ static ResultCode WaitSynchronizationN(s32* out, Kernel::Handle* handles, s32 ha | |||||||
|             return ERR_SYNC_TIMEOUT; |             return ERR_SYNC_TIMEOUT; | ||||||
|  |  | ||||||
|         // Put the thread to sleep |         // Put the thread to sleep | ||||||
|         thread->status = THREADSTATUS_WAIT_SYNCH; |         thread->status = THREADSTATUS_WAIT_SYNCH_ALL; | ||||||
|  |  | ||||||
|         // Add the thread to each of the objects' waiting threads. |         // Add the thread to each of the objects' waiting threads. | ||||||
|         for (auto& object : objects) { |         for (auto& object : objects) { | ||||||
|             object->AddWaitingThread(thread); |             object->AddWaitingThread(thread); | ||||||
|             // TODO(Subv): Perform things like update the mutex lock owner's priority to |  | ||||||
|             // prevent priority inversion. Currently this is done in Mutex::ShouldWait, |  | ||||||
|             // but it should be moved to a function that is called from here. |  | ||||||
|         } |         } | ||||||
|  |  | ||||||
|         // Set the thread's waitlist to the list of objects passed to WaitSynchronizationN |  | ||||||
|         thread->wait_objects = std::move(objects); |         thread->wait_objects = std::move(objects); | ||||||
|  |  | ||||||
|         // Create an event to wake the thread up after the specified nanosecond delay has passed |         // Create an event to wake the thread up after the specified nanosecond delay has passed | ||||||
|         thread->WakeAfterDelay(nano_seconds); |         thread->WakeAfterDelay(nano_seconds); | ||||||
|  |  | ||||||
|  |         Core::System::GetInstance().PrepareReschedule(); | ||||||
|  |  | ||||||
|         // This value gets set to -1 by default in this case, it is not modified after this. |         // This value gets set to -1 by default in this case, it is not modified after this. | ||||||
|         *out = -1; |         *out = -1; | ||||||
|         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread resumes due to |         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread resumes due to | ||||||
| @@ -373,13 +368,14 @@ static ResultCode WaitSynchronizationN(s32* out, Kernel::Handle* handles, s32 ha | |||||||
|         return ERR_SYNC_TIMEOUT; |         return ERR_SYNC_TIMEOUT; | ||||||
|     } else { |     } else { | ||||||
|         // Find the first object that is acquirable in the provided list of objects |         // Find the first object that is acquirable in the provided list of objects | ||||||
|         auto itr = std::find_if(objects.begin(), objects.end(), |         auto itr = std::find_if(objects.begin(), objects.end(), [thread](const ObjectPtr& object) { | ||||||
|                                 [](const ObjectPtr& object) { return !object->ShouldWait(); }); |             return !object->ShouldWait(thread); | ||||||
|  |         }); | ||||||
|  |  | ||||||
|         if (itr != objects.end()) { |         if (itr != objects.end()) { | ||||||
|             // We found a ready object, acquire it and set the result value |             // We found a ready object, acquire it and set the result value | ||||||
|             Kernel::WaitObject* object = itr->get(); |             Kernel::WaitObject* object = itr->get(); | ||||||
|             object->Acquire(); |             object->Acquire(thread); | ||||||
|             *out = std::distance(objects.begin(), itr); |             *out = std::distance(objects.begin(), itr); | ||||||
|             return RESULT_SUCCESS; |             return RESULT_SUCCESS; | ||||||
|         } |         } | ||||||
| @@ -392,28 +388,24 @@ static ResultCode WaitSynchronizationN(s32* out, Kernel::Handle* handles, s32 ha | |||||||
|             return ERR_SYNC_TIMEOUT; |             return ERR_SYNC_TIMEOUT; | ||||||
|  |  | ||||||
|         // Put the thread to sleep |         // Put the thread to sleep | ||||||
|         thread->status = THREADSTATUS_WAIT_SYNCH; |         thread->status = THREADSTATUS_WAIT_SYNCH_ANY; | ||||||
|  |  | ||||||
|         // Clear the thread's waitlist, we won't use it for wait_all = false |  | ||||||
|         thread->wait_objects.clear(); |  | ||||||
|  |  | ||||||
|         // Add the thread to each of the objects' waiting threads. |         // Add the thread to each of the objects' waiting threads. | ||||||
|         for (size_t i = 0; i < objects.size(); ++i) { |         for (size_t i = 0; i < objects.size(); ++i) { | ||||||
|             Kernel::WaitObject* object = objects[i].get(); |             Kernel::WaitObject* object = objects[i].get(); | ||||||
|             // Set the index of this object in the mapping of Objects -> index for this thread. |  | ||||||
|             thread->wait_objects_index[object->GetObjectId()] = static_cast<int>(i); |  | ||||||
|             object->AddWaitingThread(thread); |             object->AddWaitingThread(thread); | ||||||
|             // TODO(Subv): Perform things like update the mutex lock owner's priority to |  | ||||||
|             // prevent priority inversion. Currently this is done in Mutex::ShouldWait, |  | ||||||
|             // but it should be moved to a function that is called from here. |  | ||||||
|         } |         } | ||||||
|  |  | ||||||
|  |         thread->wait_objects = std::move(objects); | ||||||
|  |  | ||||||
|         // Note: If no handles and no timeout were given, then the thread will deadlock, this is |         // Note: If no handles and no timeout were given, then the thread will deadlock, this is | ||||||
|         // consistent with hardware behavior. |         // consistent with hardware behavior. | ||||||
|  |  | ||||||
|         // Create an event to wake the thread up after the specified nanosecond delay has passed |         // Create an event to wake the thread up after the specified nanosecond delay has passed | ||||||
|         thread->WakeAfterDelay(nano_seconds); |         thread->WakeAfterDelay(nano_seconds); | ||||||
|  |  | ||||||
|  |         Core::System::GetInstance().PrepareReschedule(); | ||||||
|  |  | ||||||
|         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread resumes due to a |         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread resumes due to a | ||||||
|         // signal in one of its wait objects. |         // signal in one of its wait objects. | ||||||
|         // Otherwise we retain the default value of timeout, and -1 in the out parameter |         // Otherwise we retain the default value of timeout, and -1 in the out parameter | ||||||
| @@ -448,6 +440,9 @@ static ResultCode ArbitrateAddress(Kernel::Handle handle, u32 address, u32 type, | |||||||
|     auto res = arbiter->ArbitrateAddress(static_cast<Kernel::ArbitrationType>(type), address, value, |     auto res = arbiter->ArbitrateAddress(static_cast<Kernel::ArbitrationType>(type), address, value, | ||||||
|                                          nanoseconds); |                                          nanoseconds); | ||||||
|  |  | ||||||
|  |     // TODO(Subv): Identify in which specific cases this call should cause a reschedule. | ||||||
|  |     Core::System::GetInstance().PrepareReschedule(); | ||||||
|  |  | ||||||
|     return res; |     return res; | ||||||
| } | } | ||||||
|  |  | ||||||
| @@ -574,6 +569,8 @@ static ResultCode CreateThread(Kernel::Handle* out_handle, s32 priority, u32 ent | |||||||
|  |  | ||||||
|     CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(thread))); |     CASCADE_RESULT(*out_handle, Kernel::g_handle_table.Create(std::move(thread))); | ||||||
|  |  | ||||||
|  |     Core::System::GetInstance().PrepareReschedule(); | ||||||
|  |  | ||||||
|     LOG_TRACE(Kernel_SVC, "called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, " |     LOG_TRACE(Kernel_SVC, "called entrypoint=0x%08X (%s), arg=0x%08X, stacktop=0x%08X, " | ||||||
|                           "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X", |                           "threadpriority=0x%08X, processorid=0x%08X : created handle=0x%08X", | ||||||
|               entry_point, name.c_str(), arg, stack_top, priority, processor_id, *out_handle); |               entry_point, name.c_str(), arg, stack_top, priority, processor_id, *out_handle); | ||||||
| @@ -586,6 +583,7 @@ static void ExitThread() { | |||||||
|     LOG_TRACE(Kernel_SVC, "called, pc=0x%08X", Core::CPU().GetPC()); |     LOG_TRACE(Kernel_SVC, "called, pc=0x%08X", Core::CPU().GetPC()); | ||||||
|  |  | ||||||
|     Kernel::ExitCurrentThread(); |     Kernel::ExitCurrentThread(); | ||||||
|  |     Core::System::GetInstance().PrepareReschedule(); | ||||||
| } | } | ||||||
|  |  | ||||||
| /// Gets the priority for the specified thread | /// Gets the priority for the specified thread | ||||||
| @@ -605,6 +603,13 @@ static ResultCode SetThreadPriority(Kernel::Handle handle, s32 priority) { | |||||||
|         return ERR_INVALID_HANDLE; |         return ERR_INVALID_HANDLE; | ||||||
|  |  | ||||||
|     thread->SetPriority(priority); |     thread->SetPriority(priority); | ||||||
|  |     thread->UpdatePriority(); | ||||||
|  |  | ||||||
|  |     // Update the mutexes that this thread is waiting for | ||||||
|  |     for (auto& mutex : thread->pending_mutexes) | ||||||
|  |         mutex->UpdatePriority(); | ||||||
|  |  | ||||||
|  |     Core::System::GetInstance().PrepareReschedule(); | ||||||
|     return RESULT_SUCCESS; |     return RESULT_SUCCESS; | ||||||
| } | } | ||||||
|  |  | ||||||
| @@ -849,6 +854,8 @@ static void SleepThread(s64 nanoseconds) { | |||||||
|  |  | ||||||
|     // Create an event to wake the thread up after the specified nanosecond delay has passed |     // Create an event to wake the thread up after the specified nanosecond delay has passed | ||||||
|     Kernel::GetCurrentThread()->WakeAfterDelay(nanoseconds); |     Kernel::GetCurrentThread()->WakeAfterDelay(nanoseconds); | ||||||
|  |  | ||||||
|  |     Core::System::GetInstance().PrepareReschedule(); | ||||||
| } | } | ||||||
|  |  | ||||||
| /// This returns the total CPU ticks elapsed since the CPU was powered-on | /// This returns the total CPU ticks elapsed since the CPU was powered-on | ||||||
| @@ -1184,8 +1191,6 @@ void CallSVC(u32 immediate) { | |||||||
|     if (info) { |     if (info) { | ||||||
|         if (info->func) { |         if (info->func) { | ||||||
|             info->func(); |             info->func(); | ||||||
|             //  TODO(Subv): Not all service functions should cause a reschedule in all cases. |  | ||||||
|             Core::System::GetInstance().PrepareReschedule(); |  | ||||||
|         } else { |         } else { | ||||||
|             LOG_ERROR(Kernel_SVC, "unimplemented SVC function %s(..)", info->name); |             LOG_ERROR(Kernel_SVC, "unimplemented SVC function %s(..)", info->name); | ||||||
|         } |         } | ||||||
|   | |||||||
		Reference in New Issue
	
	Block a user
	 Sebastian Valle
					Sebastian Valle