From bf4809fed2865da53ede58723965635e514e2ef5 Mon Sep 17 00:00:00 2001 From: kalaposfos13 <153381648+kalaposfos13@users.noreply.github.com> Date: Fri, 31 Jul 2026 00:06:13 +0200 Subject: [PATCH] Rewrite kernel event flags (#4772) * a hopefully not too questionable attempt at rewriting event flags * remove obsolete error message * misc fixes --- .../libraries/kernel/threads/event_flag.cpp | 273 +++++++++++------- 1 file changed, 168 insertions(+), 105 deletions(-) diff --git a/src/core/libraries/kernel/threads/event_flag.cpp b/src/core/libraries/kernel/threads/event_flag.cpp index 7f2fdb163..2ac4b2012 100644 --- a/src/core/libraries/kernel/threads/event_flag.cpp +++ b/src/core/libraries/kernel/threads/event_flag.cpp @@ -1,7 +1,8 @@ -// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-FileCopyrightText: Copyright 2024-2026 shadPS4 Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later #include +#include #include #include @@ -9,6 +10,7 @@ #include "common/logging/log.h" #include "core/libraries/kernel/orbis_error.h" #include "core/libraries/libs.h" +#include "pthread.h" namespace Libraries::Kernel { @@ -29,72 +31,146 @@ public: enum class ThreadMode { Single, Multi }; enum class QueueMode { Fifo, ThreadPrio }; + struct Waiter { + std::condition_variable cv{}; + + u64 bits{}; + WaitMode wait_mode{}; + ClearMode clear_mode{}; + + u64 result = 0; + + bool ready = false; + bool canceled = false; + bool deleted = false; + bool timed_out = false; + + int priority = 0; + }; + EventFlagInternal(const std::string& name, ThreadMode thread_mode, QueueMode queue_mode, - uint64_t bits) - : m_name(name), m_thread_mode(thread_mode), m_queue_mode(queue_mode), m_bits(bits) {}; + u64 bits) + : m_name(name), m_thread_mode(thread_mode), m_queue_mode(queue_mode), m_bits(bits) {} + + ~EventFlagInternal() { + std::unique_lock lock{m_mutex}; + m_deleted = true; + + for (auto* w : m_waiters) { + w->deleted = true; + w->cv.notify_one(); + } + + m_destroy_cv.wait(lock, [&] { return m_waiters.empty(); }); + } + + bool ConditionMet(const Waiter& waiter) const { + return (waiter.wait_mode == WaitMode::And) ? (m_bits & waiter.bits) == waiter.bits + : (m_bits & waiter.bits) != 0; + } + + void ApplyClear(const Waiter& waiter) { + switch (waiter.clear_mode) { + case ClearMode::None: + break; + case ClearMode::All: + m_bits = 0; + break; + case ClearMode::Bits: + m_bits &= ~waiter.bits; + break; + default: + UNREACHABLE(); + } + } + + void AddWaiter(Waiter& waiter) { + if (m_queue_mode == QueueMode::Fifo) { + m_waiters.push_back(&waiter); + return; + } + + auto it = m_waiters.begin(); + while (it != m_waiters.end() && (*it)->priority >= waiter.priority) { + ++it; + } + m_waiters.insert(it, &waiter); + } + + void RemoveWaiter(Waiter& waiter) { + m_waiters.remove(&waiter); + if (m_deleted && m_waiters.empty()) { + m_destroy_cv.notify_one(); + } + } int Wait(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result, u32* ptr_micros) { std::unique_lock lock{m_mutex}; - uint32_t micros = 0; - bool infinitely = true; - if (ptr_micros != nullptr) { - micros = *ptr_micros; - infinitely = false; - } - - if (m_thread_mode == ThreadMode::Single && m_waiting_threads > 0) { - return ORBIS_KERNEL_ERROR_EPERM; - } - - auto const start = std::chrono::system_clock::now(); - m_waiting_threads++; - auto waitFunc = [this, wait_mode, bits] { - return (m_status == Status::Canceled || m_status == Status::Deleted || - (wait_mode == WaitMode::And && (m_bits & bits) == bits) || - (wait_mode == WaitMode::Or && (m_bits & bits) != 0)); - }; - - if (infinitely) { - m_cond_var.wait(lock, waitFunc); - } else { - if (!m_cond_var.wait_for(lock, std::chrono::microseconds(micros), waitFunc)) { - if (result != nullptr) { - *result = m_bits; - } - *ptr_micros = 0; - --m_waiting_threads; - return ORBIS_KERNEL_ERROR_ETIMEDOUT; - } - } - --m_waiting_threads; - if (result != nullptr) { - *result = m_bits; - } - - auto elapsed = std::chrono::duration_cast( - std::chrono::system_clock::now() - start) - .count(); - if (result != nullptr) { - *result = m_bits; - } - - if (ptr_micros != nullptr) { - *ptr_micros = (elapsed >= micros ? 0 : micros - elapsed); - } - - if (m_status == Status::Canceled) { - return ORBIS_KERNEL_ERROR_ECANCELED; - } else if (m_status == Status::Deleted) { + if (m_deleted) { return ORBIS_KERNEL_ERROR_EACCES; } - if (clear_mode == ClearMode::All) { - m_bits = 0; - } else if (clear_mode == ClearMode::Bits) { - m_bits &= ~bits; + if (m_thread_mode == ThreadMode::Single && !m_waiters.empty()) { + return ORBIS_KERNEL_ERROR_EPERM; } + Waiter waiter{ + .bits = bits, + .wait_mode = wait_mode, + .clear_mode = clear_mode, + .priority = g_curthread->attr.prio, + }; + + if (ConditionMet(waiter)) { + if (result) + *result = m_bits; + + ApplyClear(waiter); + return ORBIS_OK; + } + + AddWaiter(waiter); + + u32 timeout = 0; + bool infinite = ptr_micros == nullptr; + + if (!infinite) + timeout = *ptr_micros; + + auto wake = [&] { + return waiter.ready || waiter.canceled || waiter.deleted || waiter.timed_out; + }; + + if (infinite) { + waiter.cv.wait(lock, wake); + } else { + if (!waiter.cv.wait_for(lock, std::chrono::microseconds(timeout), wake)) { + + RemoveWaiter(waiter); + + if (result) + *result = m_bits; + + *ptr_micros = 0; + return ORBIS_KERNEL_ERROR_ETIMEDOUT; + } + } + + RemoveWaiter(waiter); + + if (result) + *result = waiter.result; + + if (waiter.canceled) + return ORBIS_KERNEL_ERROR_ECANCELED; + + if (waiter.deleted) + return ORBIS_KERNEL_ERROR_EACCES; + + if (waiter.timed_out) + return ORBIS_KERNEL_ERROR_ETIMEDOUT; + return ORBIS_OK; } @@ -111,64 +187,55 @@ public: void Set(u64 bits) { std::unique_lock lock{m_mutex}; - while (m_status != Status::Set) { - m_mutex.unlock(); - std::this_thread::sleep_for(std::chrono::microseconds(10)); - m_mutex.lock(); - } - m_bits |= bits; - m_cond_var.notify_all(); + + for (auto it : m_waiters) { + Waiter* waiter = it; + + if (!ConditionMet(*waiter)) { + continue; + } + + waiter->result = m_bits; + ApplyClear(*waiter); + + waiter->ready = true; + waiter->cv.notify_one(); + } } void Clear(u64 bits) { - std::unique_lock lock{m_mutex}; - while (m_status != Status::Set) { - m_mutex.unlock(); - std::this_thread::sleep_for(std::chrono::microseconds(10)); - m_mutex.lock(); - } - + std::scoped_lock lock(m_mutex); m_bits &= bits; } - void Cancel(u64 setPattern, int* numWaitThreads) { - std::unique_lock lock{m_mutex}; + void Cancel(u64 pattern, int* num_waiters) { + std::scoped_lock lock(m_mutex); - while (m_status != Status::Set) { - m_mutex.unlock(); - std::this_thread::sleep_for(std::chrono::microseconds(10)); - m_mutex.lock(); + if (num_waiters) + *num_waiters = static_cast(m_waiters.size()); + + m_bits = pattern; + + for (Waiter* waiter : m_waiters) { + waiter->result = pattern; + waiter->canceled = true; + waiter->cv.notify_one(); } - - if (numWaitThreads) { - *numWaitThreads = m_waiting_threads; - } - - m_status = Status::Canceled; - m_bits = setPattern; - - m_cond_var.notify_all(); - - while (m_waiting_threads > 0) { - m_mutex.unlock(); - std::this_thread::sleep_for(std::chrono::microseconds(10)); - m_mutex.lock(); - } - - m_status = Status::Set; } private: - enum class Status { Set, Canceled, Deleted }; - std::mutex m_mutex; - std::condition_variable m_cond_var; - Status m_status = Status::Set; - int m_waiting_threads = 0; + + std::list m_waiters; + std::condition_variable m_destroy_cv; + std::string m_name; - ThreadMode m_thread_mode = ThreadMode::Single; - QueueMode m_queue_mode = QueueMode::Fifo; + + ThreadMode m_thread_mode; + QueueMode m_queue_mode; + bool m_deleted = false; + u64 m_bits = 0; }; @@ -223,10 +290,6 @@ int PS4_SYSV_ABI sceKernelCreateEventFlag(OrbisKernelEventFlag* ef, const char* UNREACHABLE(); } - if (queue_mode == EventFlagInternal::QueueMode::ThreadPrio) { - LOG_ERROR(Kernel_Event, "ThreadPriority attr is not supported!"); - } - *ef = new EventFlagInternal(std::string(pName), thread_mode, queue_mode, initPattern); return ORBIS_OK; }