mirror of
https://github.com/shadps4-emu/shadPS4.git
synced 2026-11-17 19:44:36 +01:00
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:
1 parent
34e0f83998
commit
bf4809fed2
1 file changed
+168
-105
@@ -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;
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user