Rewrite kernel event flags (#4772)

* a hopefully not too questionable attempt at rewriting event flags

* remove obsolete error message

* misc fixes
This commit is contained in:
kalaposfos13 authored and GitHub committed 2026-07-31 01:06:13 +03:00
1 parent 34e0f83998
commit bf4809fed2
1 file changed
+168 -105
+168 -105
View File
@@ -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 <condition_variable>
#include <list>
#include <mutex>
#include <thread>
@@ -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::microseconds>(
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<int>(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<Waiter*> 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;
}