From 1dfa91b638cc5022a54ea362ecc254050c6531eb Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Tue, 28 May 2024 14:29:53 +0300 Subject: [PATCH 1/3] event flag implementation from previous pr --- CMakeLists.txt | 7 +- .../kernel/event_flag/event_flag.cpp | 141 ++++++++++++++++++ .../libraries/kernel/event_flag/event_flag.h | 40 +++++ .../kernel/event_flag/event_flag_codes.h | 14 ++ .../kernel/event_flag/event_flag_obj.cpp | 73 +++++++++ .../kernel/event_flag/event_flag_obj.h | 34 +++++ src/core/libraries/kernel/libkernel.cpp | 2 + 7 files changed, 310 insertions(+), 1 deletion(-) create mode 100644 src/core/libraries/kernel/event_flag/event_flag.cpp create mode 100644 src/core/libraries/kernel/event_flag/event_flag.h create mode 100644 src/core/libraries/kernel/event_flag/event_flag_codes.h create mode 100644 src/core/libraries/kernel/event_flag/event_flag_obj.cpp create mode 100644 src/core/libraries/kernel/event_flag/event_flag_obj.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 520ba4c8..a79c1bd6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -100,7 +100,12 @@ set(GNM_LIB src/core/libraries/gnmdriver/gnmdriver.cpp src/core/libraries/gnmdriver/gnmdriver.h ) -set(KERNEL_LIB src/core/libraries/kernel/cpu_management.cpp +set(KERNEL_LIB + src/core/libraries/kernel/event_flag/event_flag.cpp + src/core/libraries/kernel/event_flag/event_flag.h + src/core/libraries/kernel/event_flag/event_flag_obj.cpp + src/core/libraries/kernel/event_flag/event_flag_obj.h + src/core/libraries/kernel/cpu_management.cpp src/core/libraries/kernel/cpu_management.h src/core/libraries/kernel/event_queue.cpp src/core/libraries/kernel/event_queue.h diff --git a/src/core/libraries/kernel/event_flag/event_flag.cpp b/src/core/libraries/kernel/event_flag/event_flag.cpp new file mode 100644 index 00000000..01efad70 --- /dev/null +++ b/src/core/libraries/kernel/event_flag/event_flag.cpp @@ -0,0 +1,141 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include "common/logging/log.h" +#include "core/libraries/error_codes.h" +#include "core/libraries/libs.h" +#include "event_flag.h" + +namespace Libraries::Kernel { +int PS4_SYSV_ABI sceKernelCreateEventFlag(OrbisKernelEventFlag* ef, const char* pName, u32 attr, + u64 initPattern, + const OrbisKernelEventFlagOptParam* pOptParam) { + LOG_INFO(Kernel_Event, "called name = {} attr = {:#x} initPattern = {:#x}", pName, attr, + initPattern); + if (ef == nullptr || pName == nullptr) { + return ORBIS_KERNEL_ERROR_EINVAL; + } + if (pOptParam || !pName || + attr > (ORBIS_KERNEL_EVF_ATTR_MULTI | ORBIS_KERNEL_EVF_ATTR_TH_PRIO)) { + return SCE_KERNEL_ERROR_EINVAL; + } + + if (strlen(pName) >= 32) { + return ORBIS_KERNEL_ERROR_ENAMETOOLONG; + } + + bool single = true; + bool fifo = true; + + switch (attr) { + case 0x10: + case 0x11: + single = true; + fifo = true; + break; + case 0x20: + case 0x21: + single = false; + fifo = true; + break; + case 0x22: + single = false; + fifo = false; + break; + default: + UNREACHABLE(); + } + + *ef = new EventFlagInternal(std::string(pName), single, fifo, initPattern); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelDeleteEventFlag(OrbisKernelEventFlag ef) { + LOG_ERROR(Kernel_Event, "(STUBBED) called"); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelOpenEventFlag() { + LOG_ERROR(Kernel_Event, "(STUBBED) called"); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelCloseEventFlag() { + LOG_ERROR(Kernel_Event, "(STUBBED) called"); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelClearEventFlag(OrbisKernelEventFlag ef, u64 bitPattern) { + LOG_ERROR(Kernel_Event, "(STUBBED) called"); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelCancelEventFlag(OrbisKernelEventFlag ef, u64 setPattern, + int* pNumWaitThreads) { + LOG_ERROR(Kernel_Event, "(STUBBED) called"); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelSetEventFlag(OrbisKernelEventFlag ef, u64 bitPattern) { + LOG_ERROR(Kernel_Event, "(STUBBED) called"); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelPollEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode, + u64* pResultPat) { + LOG_ERROR(Kernel_Event, "(STUBBED) called"); + return ORBIS_OK; +} +int PS4_SYSV_ABI sceKernelWaitEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode, + u64* pResultPat, OrbisKernelUseconds* pTimeout) { + LOG_INFO(Kernel_Event, "called bitPattern = {:#x} waitMode = {:#x}", bitPattern, waitMode); + if (ef == nullptr) { + return ORBIS_KERNEL_ERROR_ESRCH; + } + + if (bitPattern == 0) { + return ORBIS_KERNEL_ERROR_EINVAL; + } + + EventFlagInternal::WaitMode wait = EventFlagInternal::WaitMode::And; + EventFlagInternal::ClearMode clear = EventFlagInternal::ClearMode::None; + + switch (waitMode & 0xf) { + case 0x01: + wait = EventFlagInternal::WaitMode::And; + break; + case 0x02: + wait = EventFlagInternal::WaitMode::Or; + break; + default: + UNREACHABLE(); + } + + switch (waitMode & 0xf0) { + case 0x00: + clear = EventFlagInternal::ClearMode::None; + break; + case 0x10: + clear = EventFlagInternal::ClearMode::All; + break; + case 0x20: + clear = EventFlagInternal::ClearMode::Bits; + break; + default: + UNREACHABLE(); + } + + auto result = ef->Wait(bitPattern, wait, clear, pResultPat, pTimeout); + + if (result != ORBIS_OK) { + LOG_ERROR(Kernel_Event, "returned {}", result); + } + + return result; +} +void RegisterKernelEventFlag(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("PZku4ZrXJqg", "libkernel", 1, "libkernel", 1, 1, sceKernelCancelEventFlag); + LIB_FUNCTION("7uhBFWRAS60", "libkernel", 1, "libkernel", 1, 1, sceKernelClearEventFlag); + LIB_FUNCTION("s9-RaxukuzQ", "libkernel", 1, "libkernel", 1, 1, sceKernelCloseEventFlag); + LIB_FUNCTION("BpFoboUJoZU", "libkernel", 1, "libkernel", 1, 1, sceKernelCreateEventFlag); + LIB_FUNCTION("8mql9OcQnd4", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteEventFlag); + LIB_FUNCTION("1vDaenmJtyA", "libkernel", 1, "libkernel", 1, 1, sceKernelOpenEventFlag); + LIB_FUNCTION("9lvj5DjHZiA", "libkernel", 1, "libkernel", 1, 1, sceKernelPollEventFlag); + LIB_FUNCTION("IOnSvHzqu6A", "libkernel", 1, "libkernel", 1, 1, sceKernelSetEventFlag); + LIB_FUNCTION("JTvBflhYazQ", "libkernel", 1, "libkernel", 1, 1, sceKernelWaitEventFlag); +} +} // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/kernel/event_flag/event_flag.h b/src/core/libraries/kernel/event_flag/event_flag.h new file mode 100644 index 00000000..2147e3f1 --- /dev/null +++ b/src/core/libraries/kernel/event_flag/event_flag.h @@ -0,0 +1,40 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "common/types.h" +#include "event_flag_codes.h" +#include "event_flag_obj.h" + +namespace Core::Loader { +class SymbolsResolver; +} + +namespace Libraries::Kernel { + +using OrbisKernelUseconds = u32; +using OrbisKernelEventFlag = EventFlagInternal*; + +struct OrbisKernelEventFlagOptParam { + size_t size; +}; + +int PS4_SYSV_ABI sceKernelCreateEventFlag(OrbisKernelEventFlag* ef, const char* pName, u32 attr, + u64 initPattern, + const OrbisKernelEventFlagOptParam* pOptParam); +int PS4_SYSV_ABI sceKernelDeleteEventFlag(OrbisKernelEventFlag ef); +int PS4_SYSV_ABI sceKernelOpenEventFlag(); +int PS4_SYSV_ABI sceKernelCloseEventFlag(); +int PS4_SYSV_ABI sceKernelClearEventFlag(OrbisKernelEventFlag ef, u64 bitPattern); +int PS4_SYSV_ABI sceKernelCancelEventFlag(OrbisKernelEventFlag ef, u64 setPattern, + int* pNumWaitThreads); +int PS4_SYSV_ABI sceKernelSetEventFlag(OrbisKernelEventFlag ef, u64 bitPattern); +int PS4_SYSV_ABI sceKernelPollEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode, + u64* pResultPat); +int PS4_SYSV_ABI sceKernelWaitEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode, + u64* pResultPat, OrbisKernelUseconds* pTimeout); + +void RegisterKernelEventFlag(Core::Loader::SymbolsResolver* sym); + +} // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/kernel/event_flag/event_flag_codes.h b/src/core/libraries/kernel/event_flag/event_flag_codes.h new file mode 100644 index 00000000..92b265c8 --- /dev/null +++ b/src/core/libraries/kernel/event_flag/event_flag_codes.h @@ -0,0 +1,14 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +constexpr int ORBIS_KERNEL_EVF_ATTR_TH_FIFO = 0x01; +constexpr int ORBIS_KERNEL_EVF_ATTR_TH_PRIO = 0x02; +constexpr int ORBIS_KERNEL_EVF_ATTR_SINGLE = 0x10; +constexpr int ORBIS_KERNEL_EVF_ATTR_MULTI = 0x20; + +constexpr int ORBIS_KERNEL_EVF_WAITMODE_AND = 0x01; +constexpr int ORBIS_KERNEL_EVF_WAITMODE_OR = 0x02; +constexpr int ORBIS_KERNEL_EVF_WAITMODE_CLEAR_ALL = 0x10; +constexpr int ORBIS_KERNEL_EVF_WAITMODE_CLEAR_PAT = 0x20; \ No newline at end of file diff --git a/src/core/libraries/kernel/event_flag/event_flag_obj.cpp b/src/core/libraries/kernel/event_flag/event_flag_obj.cpp new file mode 100644 index 00000000..86250c35 --- /dev/null +++ b/src/core/libraries/kernel/event_flag/event_flag_obj.cpp @@ -0,0 +1,73 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include +#include "event_flag_obj.h" + +namespace Libraries::Kernel { +int EventFlagInternal::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_single_thread && 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) { + return ORBIS_KERNEL_ERROR_EACCES; + } + + if (clear_mode == ClearMode::All) { + m_bits = 0; + } else if (clear_mode == ClearMode::Bits) { + m_bits &= ~bits; + } + + return ORBIS_OK; +} +} // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/kernel/event_flag/event_flag_obj.h b/src/core/libraries/kernel/event_flag/event_flag_obj.h new file mode 100644 index 00000000..9284ec56 --- /dev/null +++ b/src/core/libraries/kernel/event_flag/event_flag_obj.h @@ -0,0 +1,34 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once +#include +#include +#include "common/types.h" + +namespace Libraries::Kernel { + +class EventFlagInternal { +public: + enum class ClearMode { None, All, Bits }; + + enum class WaitMode { And, Or }; + + EventFlagInternal(const std::string& name, bool single, bool fifo, uint64_t bits) + : m_name(name), m_single_thread(single), m_fifo(fifo), m_bits(bits){}; + + int Wait(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result, u32* ptr_micros); + +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::string m_name; + bool m_single_thread = false; + bool m_fifo = false; + u64 m_bits = 0; +}; +} // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/kernel/libkernel.cpp b/src/core/libraries/kernel/libkernel.cpp index 3f3a3624..a6c2231a 100644 --- a/src/core/libraries/kernel/libkernel.cpp +++ b/src/core/libraries/kernel/libkernel.cpp @@ -8,6 +8,7 @@ #include "common/singleton.h" #include "core/libraries/error_codes.h" #include "core/libraries/kernel/cpu_management.h" +#include "core/libraries/kernel/event_flag/event_flag.h" #include "core/libraries/kernel/event_queues.h" #include "core/libraries/kernel/file_system.h" #include "core/libraries/kernel/libkernel.h" @@ -231,6 +232,7 @@ void LibKernel_Register(Core::Loader::SymbolsResolver* sym) { Libraries::Kernel::fileSystemSymbolsRegister(sym); Libraries::Kernel::timeSymbolsRegister(sym); Libraries::Kernel::pthreadSymbolsRegister(sym); + Libraries::Kernel::RegisterKernelEventFlag(sym); // temp LIB_FUNCTION("NWtTN10cJzE", "libSceLibcInternalExt", 1, "libSceLibcInternal", 1, 1, From 4d5e9d1da495ea8ed31c7879f20ffb2db3b8e4b8 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Tue, 28 May 2024 15:13:56 +0300 Subject: [PATCH 2/3] set,poll event flag --- .../kernel/event_flag/event_flag.cpp | 53 +++++++++++++++++-- .../kernel/event_flag/event_flag_obj.cpp | 20 +++++++ .../kernel/event_flag/event_flag_obj.h | 2 + 3 files changed, 72 insertions(+), 3 deletions(-) diff --git a/src/core/libraries/kernel/event_flag/event_flag.cpp b/src/core/libraries/kernel/event_flag/event_flag.cpp index 01efad70..fffce0f7 100644 --- a/src/core/libraries/kernel/event_flag/event_flag.cpp +++ b/src/core/libraries/kernel/event_flag/event_flag.cpp @@ -72,13 +72,60 @@ int PS4_SYSV_ABI sceKernelCancelEventFlag(OrbisKernelEventFlag ef, u64 setPatter return ORBIS_OK; } int PS4_SYSV_ABI sceKernelSetEventFlag(OrbisKernelEventFlag ef, u64 bitPattern) { - LOG_ERROR(Kernel_Event, "(STUBBED) called"); + LOG_TRACE(Kernel_Event, "called"); + if (ef == nullptr) { + return ORBIS_KERNEL_ERROR_ESRCH; + } + ef->Set(bitPattern); return ORBIS_OK; } int PS4_SYSV_ABI sceKernelPollEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode, u64* pResultPat) { - LOG_ERROR(Kernel_Event, "(STUBBED) called"); - return ORBIS_OK; + LOG_INFO(Kernel_Event, "called bitPattern = {:#x} waitMode = {:#x}", bitPattern, waitMode); + + if (ef == nullptr) { + return ORBIS_KERNEL_ERROR_ESRCH; + } + + if (bitPattern == 0) { + return ORBIS_KERNEL_ERROR_EINVAL; + } + + EventFlagInternal::WaitMode wait = EventFlagInternal::WaitMode::And; + EventFlagInternal::ClearMode clear = EventFlagInternal::ClearMode::None; + + switch (waitMode & 0xf) { + case 0x01: + wait = EventFlagInternal::WaitMode::And; + break; + case 0x02: + wait = EventFlagInternal::WaitMode::Or; + break; + default: + UNREACHABLE(); + } + + switch (waitMode & 0xf0) { + case 0x00: + clear = EventFlagInternal::ClearMode::None; + break; + case 0x10: + clear = EventFlagInternal::ClearMode::All; + break; + case 0x20: + clear = EventFlagInternal::ClearMode::Bits; + break; + default: + UNREACHABLE(); + } + + auto result = ef->Poll(bitPattern, wait, clear, pResultPat); + + if (result != ORBIS_OK) { + LOG_ERROR(Kernel_Event, "returned {}", result); + } + + return result; } int PS4_SYSV_ABI sceKernelWaitEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode, u64* pResultPat, OrbisKernelUseconds* pTimeout) { diff --git a/src/core/libraries/kernel/event_flag/event_flag_obj.cpp b/src/core/libraries/kernel/event_flag/event_flag_obj.cpp index 86250c35..069ae9dc 100644 --- a/src/core/libraries/kernel/event_flag/event_flag_obj.cpp +++ b/src/core/libraries/kernel/event_flag/event_flag_obj.cpp @@ -70,4 +70,24 @@ int EventFlagInternal::Wait(u64 bits, WaitMode wait_mode, ClearMode clear_mode, return ORBIS_OK; } + +int EventFlagInternal::Poll(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result) { + u32 micros = 0; + return Wait(bits, wait_mode, clear_mode, result, µs); +} + +void EventFlagInternal::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(); +} + } // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/kernel/event_flag/event_flag_obj.h b/src/core/libraries/kernel/event_flag/event_flag_obj.h index 9284ec56..a4a85a8e 100644 --- a/src/core/libraries/kernel/event_flag/event_flag_obj.h +++ b/src/core/libraries/kernel/event_flag/event_flag_obj.h @@ -18,6 +18,8 @@ public: : m_name(name), m_single_thread(single), m_fifo(fifo), m_bits(bits){}; int Wait(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result, u32* ptr_micros); + int Poll(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result); + void Set(u64 bits); private: enum class Status { Set, Canceled, Deleted }; From d30703b4eba063f8183b95f57e81e33ab77180c0 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Tue, 28 May 2024 18:24:42 +0300 Subject: [PATCH 3/3] improvements in definations --- .../kernel/event_flag/event_flag.cpp | 40 +++++++++++-------- .../kernel/event_flag/event_flag_obj.cpp | 2 +- .../kernel/event_flag/event_flag_obj.h | 13 ++++-- 3 files changed, 34 insertions(+), 21 deletions(-) diff --git a/src/core/libraries/kernel/event_flag/event_flag.cpp b/src/core/libraries/kernel/event_flag/event_flag.cpp index fffce0f7..659d3cd7 100644 --- a/src/core/libraries/kernel/event_flag/event_flag.cpp +++ b/src/core/libraries/kernel/event_flag/event_flag.cpp @@ -18,36 +18,44 @@ int PS4_SYSV_ABI sceKernelCreateEventFlag(OrbisKernelEventFlag* ef, const char* } if (pOptParam || !pName || attr > (ORBIS_KERNEL_EVF_ATTR_MULTI | ORBIS_KERNEL_EVF_ATTR_TH_PRIO)) { - return SCE_KERNEL_ERROR_EINVAL; + return ORBIS_KERNEL_ERROR_EINVAL; } if (strlen(pName) >= 32) { return ORBIS_KERNEL_ERROR_ENAMETOOLONG; } - bool single = true; - bool fifo = true; + EventFlagInternal::ThreadMode thread_mode = EventFlagInternal::ThreadMode::Single; + EventFlagInternal::QueueMode queue_mode = EventFlagInternal::QueueMode::Fifo; - switch (attr) { - case 0x10: - case 0x11: - single = true; - fifo = true; + switch (attr & 0xfu) { + case 0x01: + queue_mode = EventFlagInternal::QueueMode::Fifo; break; - case 0x20: - case 0x21: - single = false; - fifo = true; + case 0x02: + queue_mode = EventFlagInternal::QueueMode::ThreadPrio; break; - case 0x22: - single = false; - fifo = false; + case 0x00: break; default: UNREACHABLE(); } - *ef = new EventFlagInternal(std::string(pName), single, fifo, initPattern); + switch (attr & 0xf0) { + case 0x10: + thread_mode = EventFlagInternal::ThreadMode::Single; + break; + case 0x20: + thread_mode = EventFlagInternal::ThreadMode::Multi; + break; + default: + UNREACHABLE(); + } + + ASSERT_MSG(queue_mode == EventFlagInternal::QueueMode::Fifo, + "ThreadPriority attr is not supported!"); + + *ef = new EventFlagInternal(std::string(pName), thread_mode, queue_mode, initPattern); return ORBIS_OK; } int PS4_SYSV_ABI sceKernelDeleteEventFlag(OrbisKernelEventFlag ef) { diff --git a/src/core/libraries/kernel/event_flag/event_flag_obj.cpp b/src/core/libraries/kernel/event_flag/event_flag_obj.cpp index 069ae9dc..66f0d3d7 100644 --- a/src/core/libraries/kernel/event_flag/event_flag_obj.cpp +++ b/src/core/libraries/kernel/event_flag/event_flag_obj.cpp @@ -16,7 +16,7 @@ int EventFlagInternal::Wait(u64 bits, WaitMode wait_mode, ClearMode clear_mode, infinitely = false; } - if (m_single_thread && m_waiting_threads > 0) { + if (m_thread_mode == ThreadMode::Single && m_waiting_threads > 0) { return ORBIS_KERNEL_ERROR_EPERM; } diff --git a/src/core/libraries/kernel/event_flag/event_flag_obj.h b/src/core/libraries/kernel/event_flag/event_flag_obj.h index a4a85a8e..efeee088 100644 --- a/src/core/libraries/kernel/event_flag/event_flag_obj.h +++ b/src/core/libraries/kernel/event_flag/event_flag_obj.h @@ -14,8 +14,13 @@ public: enum class WaitMode { And, Or }; - EventFlagInternal(const std::string& name, bool single, bool fifo, uint64_t bits) - : m_name(name), m_single_thread(single), m_fifo(fifo), m_bits(bits){}; + enum class ThreadMode { Single, Multi }; + + enum class QueueMode { Fifo, ThreadPrio }; + + 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){}; int Wait(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result, u32* ptr_micros); int Poll(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result); @@ -29,8 +34,8 @@ private: Status m_status = Status::Set; int m_waiting_threads = 0; std::string m_name; - bool m_single_thread = false; - bool m_fifo = false; + ThreadMode m_thread_mode = ThreadMode::Single; + QueueMode m_queue_mode = QueueMode::Fifo; u64 m_bits = 0; }; } // namespace Libraries::Kernel \ No newline at end of file