From d92989e7879bb1f4e6788fcc96f02e357e5c38e0 Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Mon, 26 Nov 2018 18:29:50 -0500 Subject: kernel/object: Add descriptions to ResetTypes --- src/core/hle/kernel/object.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/core/hle/kernel/object.h b/src/core/hle/kernel/object.h index c9f4d0bb3..69082ce3e 100644 --- a/src/core/hle/kernel/object.h +++ b/src/core/hle/kernel/object.h @@ -33,9 +33,9 @@ enum class HandleType : u32 { }; enum class ResetType { - OneShot, - Sticky, - Pulse, + OneShot, ///< Reset automatically on object acquisition + Sticky, ///< Never reset automatically + Pulse, ///< Reset automatically on wakeup }; class Object : NonCopyable { -- cgit v1.2.3 From c7133838161ce0c17276ef96c0decfb855510165 Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Mon, 26 Nov 2018 18:31:22 -0500 Subject: kernel: Divide Event into ReadableEvent and WritableEvent More hardware accurate. On the actual system, there is a differentiation between the signaler and signalee, they form a client/server relationship much like ServerPort and ClientPort. --- src/core/CMakeLists.txt | 6 ++- src/core/hle/kernel/event.cpp | 53 ---------------------- src/core/hle/kernel/event.h | 60 ------------------------- src/core/hle/kernel/readable_event.cpp | 48 ++++++++++++++++++++ src/core/hle/kernel/readable_event.h | 56 +++++++++++++++++++++++ src/core/hle/kernel/writable_event.cpp | 81 ++++++++++++++++++++++++++++++++++ src/core/hle/kernel/writable_event.h | 75 +++++++++++++++++++++++++++++++ 7 files changed, 264 insertions(+), 115 deletions(-) delete mode 100644 src/core/hle/kernel/event.cpp delete mode 100644 src/core/hle/kernel/event.h create mode 100644 src/core/hle/kernel/readable_event.cpp create mode 100644 src/core/hle/kernel/readable_event.h create mode 100644 src/core/hle/kernel/writable_event.cpp create mode 100644 src/core/hle/kernel/writable_event.h diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index e1f21a764..73aec8ab0 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -97,8 +97,6 @@ add_library(core STATIC hle/kernel/client_session.cpp hle/kernel/client_session.h hle/kernel/errors.h - hle/kernel/event.cpp - hle/kernel/event.h hle/kernel/handle_table.cpp hle/kernel/handle_table.h hle/kernel/hle_ipc.cpp @@ -111,6 +109,8 @@ add_library(core STATIC hle/kernel/object.h hle/kernel/process.cpp hle/kernel/process.h + hle/kernel/readable_event.cpp + hle/kernel/readable_event.h hle/kernel/resource_limit.cpp hle/kernel/resource_limit.h hle/kernel/scheduler.cpp @@ -133,6 +133,8 @@ add_library(core STATIC hle/kernel/vm_manager.h hle/kernel/wait_object.cpp hle/kernel/wait_object.h + hle/kernel/writable_event.cpp + hle/kernel/writable_event.h hle/lock.cpp hle/lock.h hle/result.h diff --git a/src/core/hle/kernel/event.cpp b/src/core/hle/kernel/event.cpp deleted file mode 100644 index 8967e602e..000000000 --- a/src/core/hle/kernel/event.cpp +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#include -#include "common/assert.h" -#include "core/hle/kernel/event.h" -#include "core/hle/kernel/object.h" -#include "core/hle/kernel/thread.h" - -namespace Kernel { - -Event::Event(KernelCore& kernel) : WaitObject{kernel} {} -Event::~Event() = default; - -SharedPtr Event::Create(KernelCore& kernel, ResetType reset_type, std::string name) { - SharedPtr evt(new Event(kernel)); - - evt->signaled = false; - evt->reset_type = reset_type; - evt->name = std::move(name); - - return evt; -} - -bool Event::ShouldWait(Thread* thread) const { - return !signaled; -} - -void Event::Acquire(Thread* thread) { - ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); - - if (reset_type == ResetType::OneShot) - signaled = false; -} - -void Event::Signal() { - signaled = true; - WakeupAllWaitingThreads(); -} - -void Event::Clear() { - signaled = false; -} - -void Event::WakeupAllWaitingThreads() { - WaitObject::WakeupAllWaitingThreads(); - - if (reset_type == ResetType::Pulse) - signaled = false; -} - -} // namespace Kernel diff --git a/src/core/hle/kernel/event.h b/src/core/hle/kernel/event.h deleted file mode 100644 index 27d6126b0..000000000 --- a/src/core/hle/kernel/event.h +++ /dev/null @@ -1,60 +0,0 @@ -// Copyright 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#pragma once - -#include "common/common_types.h" -#include "core/hle/kernel/object.h" -#include "core/hle/kernel/wait_object.h" - -namespace Kernel { - -class KernelCore; - -class Event final : public WaitObject { -public: - /** - * Creates an event - * @param kernel The kernel instance to create this event under. - * @param reset_type ResetType describing how to create event - * @param name Optional name of event - */ - static SharedPtr Create(KernelCore& kernel, ResetType reset_type, - std::string name = "Unknown"); - - std::string GetTypeName() const override { - return "Event"; - } - std::string GetName() const override { - return name; - } - - static const HandleType HANDLE_TYPE = HandleType::Event; - HandleType GetHandleType() const override { - return HANDLE_TYPE; - } - - ResetType GetResetType() const { - return reset_type; - } - - bool ShouldWait(Thread* thread) const override; - void Acquire(Thread* thread) override; - - void WakeupAllWaitingThreads() override; - - void Signal(); - void Clear(); - -private: - explicit Event(KernelCore& kernel); - ~Event() override; - - ResetType reset_type; ///< Current ResetType - - bool signaled; ///< Whether the event has already been signaled - std::string name; ///< Name of event (optional) -}; - -} // namespace Kernel diff --git a/src/core/hle/kernel/readable_event.cpp b/src/core/hle/kernel/readable_event.cpp new file mode 100644 index 000000000..164cffbdb --- /dev/null +++ b/src/core/hle/kernel/readable_event.cpp @@ -0,0 +1,48 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include "common/assert.h" +#include "core/hle/kernel/object.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/thread.h" +#include "core/hle/kernel/writable_event.h" + +namespace Kernel { + +ReadableEvent::ReadableEvent(KernelCore& kernel) : WaitObject{kernel} {} +ReadableEvent::~ReadableEvent() = default; + +bool ReadableEvent::ShouldWait(Thread* thread) const { + return !writable_event->IsSignaled(); +} + +void ReadableEvent::Acquire(Thread* thread) { + ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); + + writable_event->ResetOnAcquire(); +} + +void ReadableEvent::AddWaitingThread(SharedPtr thread) { + writable_event->AddWaitingThread(thread); +} + +void ReadableEvent::RemoveWaitingThread(Thread* thread) { + writable_event->RemoveWaitingThread(thread); +} + +void ReadableEvent::Signal() { + writable_event->Signal(); +} + +void ReadableEvent::Clear() { + writable_event->Clear(); +} + +void ReadableEvent::WakeupAllWaitingThreads() { + writable_event->WakeupAllWaitingThreads(); + writable_event->ResetOnWakeup(); +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/readable_event.h b/src/core/hle/kernel/readable_event.h new file mode 100644 index 000000000..020ef4ebc --- /dev/null +++ b/src/core/hle/kernel/readable_event.h @@ -0,0 +1,56 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/kernel/object.h" +#include "core/hle/kernel/wait_object.h" + +namespace Kernel { + +class KernelCore; +class WritableEvent; + +class ReadableEvent final : public WaitObject { + friend class WritableEvent; + +public: + ~ReadableEvent() override; + + std::string GetTypeName() const override { + return "ReadableEvent"; + } + std::string GetName() const override { + return name; + } + + static const HandleType HANDLE_TYPE = HandleType::Event; + HandleType GetHandleType() const override { + return HANDLE_TYPE; + } + + bool ShouldWait(Thread* thread) const override; + void Acquire(Thread* thread) override; + + void WakeupAllWaitingThreads() override; + + void AddWaitingThread(SharedPtr thread) override; + void RemoveWaitingThread(Thread* thread) override; + + void Signal(); + void Clear(); + + SharedPtr PromoteToWritable() const { + return writable_event; + } + +private: + explicit ReadableEvent(KernelCore& kernel); + + SharedPtr writable_event; ///< WritableEvent associated with this ReadableEvent + + std::string name; ///< Name of event (optional) +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/writable_event.cpp b/src/core/hle/kernel/writable_event.cpp new file mode 100644 index 000000000..4eb387ac0 --- /dev/null +++ b/src/core/hle/kernel/writable_event.cpp @@ -0,0 +1,81 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include "common/assert.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/object.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/thread.h" +#include "core/hle/kernel/writable_event.h" + +namespace Kernel { + +WritableEvent::WritableEvent(KernelCore& kernel) : WaitObject{kernel} {} +WritableEvent::~WritableEvent() = default; + +std::tuple, SharedPtr> WritableEvent::CreateEventPair( + KernelCore& kernel, ResetType reset_type, std::string name) { + SharedPtr writable_event(new WritableEvent(kernel)); + SharedPtr readable_event(new ReadableEvent(kernel)); + + writable_event->name = name + ":Writable"; + writable_event->signaled = false; + writable_event->reset_type = reset_type; + readable_event->name = name + ":Readable"; + readable_event->writable_event = writable_event; + + return std::make_tuple(std::move(writable_event), std::move(readable_event)); +} + +SharedPtr WritableEvent::CreateRegisteredEventPair(KernelCore& kernel, + ResetType reset_type, + std::string name) { + auto [writable_event, readable_event] = CreateEventPair(kernel, reset_type, name); + kernel.AddNamedEvent(name, std::move(readable_event)); + return std::move(writable_event); +} + +bool WritableEvent::ShouldWait(Thread* thread) const { + return !signaled; +} + +void WritableEvent::Acquire(Thread* thread) { + ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); + + if (reset_type == ResetType::OneShot) + signaled = false; +} + +void WritableEvent::Signal() { + signaled = true; + WakeupAllWaitingThreads(); +} + +void WritableEvent::Clear() { + signaled = false; +} + +void WritableEvent::ResetOnAcquire() { + if (reset_type == ResetType::OneShot) + Clear(); +} + +void WritableEvent::ResetOnWakeup() { + if (reset_type == ResetType::Pulse) + Clear(); +} + +bool WritableEvent::IsSignaled() const { + return signaled; +} + +void WritableEvent::WakeupAllWaitingThreads() { + WaitObject::WakeupAllWaitingThreads(); + + if (reset_type == ResetType::Pulse) + signaled = false; +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/writable_event.h b/src/core/hle/kernel/writable_event.h new file mode 100644 index 000000000..c0fe42302 --- /dev/null +++ b/src/core/hle/kernel/writable_event.h @@ -0,0 +1,75 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" +#include "core/hle/kernel/object.h" +#include "core/hle/kernel/wait_object.h" + +namespace Kernel { + +class KernelCore; +class ReadableEvent; + +class WritableEvent final : public WaitObject { +public: + ~WritableEvent() override; + + /** + * Creates an event + * @param kernel The kernel instance to create this event under. + * @param reset_type ResetType describing how to create event + * @param name Optional name of event + */ + static std::tuple, SharedPtr> CreateEventPair( + KernelCore& kernel, ResetType reset_type, std::string name = "Unknown"); + + /** + * Creates an event and registers it in the kernel's named event table + * @param kernel The kernel instance to create this event under. + * @param reset_type ResetType describing how to create event + * @param name name of event + */ + static SharedPtr CreateRegisteredEventPair(KernelCore& kernel, + ResetType reset_type, + std::string name); + + std::string GetTypeName() const override { + return "WritableEvent"; + } + std::string GetName() const override { + return name; + } + + static const HandleType HANDLE_TYPE = HandleType::Event; + HandleType GetHandleType() const override { + return HANDLE_TYPE; + } + + ResetType GetResetType() const { + return reset_type; + } + + bool ShouldWait(Thread* thread) const override; + void Acquire(Thread* thread) override; + + void WakeupAllWaitingThreads() override; + + void Signal(); + void Clear(); + void ResetOnAcquire(); + void ResetOnWakeup(); + bool IsSignaled() const; + +private: + explicit WritableEvent(KernelCore& kernel); + + ResetType reset_type; ///< Current ResetType + + bool signaled; ///< Whether the event has already been signaled + std::string name; ///< Name of event (optional) +}; + +} // namespace Kernel -- cgit v1.2.3 From c61d2a28413bd149d58b1173fa89a250ddce03c4 Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Mon, 26 Nov 2018 18:32:13 -0500 Subject: kernel: Add named event table Used to store ReadableEvents of all events on the system. --- src/core/hle/kernel/kernel.cpp | 19 +++++++++++++++++++ src/core/hle/kernel/kernel.h | 11 +++++++++++ 2 files changed, 30 insertions(+) diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index e441c5bc6..9cd714586 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -17,9 +17,11 @@ #include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/process.h" +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/resource_limit.h" #include "core/hle/kernel/thread.h" #include "core/hle/kernel/timer.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/lock.h" #include "core/hle/result.h" @@ -175,6 +177,10 @@ struct KernelCore::Impl { // allowing us to simply use a pool index or similar. Kernel::HandleTable thread_wakeup_callback_handle_table; + /// Map of named events managed by the kernel, which are retrieved when HLE services need to + /// return an event to the system. + NamedEventTable named_events; + /// Map of named ports managed by the kernel, which can be retrieved using /// the ConnectToPort SVC. NamedPortTable named_ports; @@ -221,6 +227,19 @@ const Process* KernelCore::CurrentProcess() const { return impl->current_process; } +void KernelCore::AddNamedEvent(std::string name, SharedPtr event) { + impl->named_events.emplace(std::move(name), std::move(event)); +} + +KernelCore::NamedEventTable::iterator KernelCore::FindNamedEvent(const std::string& name) { + return impl->named_events.find(name); +} + +KernelCore::NamedEventTable::const_iterator KernelCore::FindNamedEvent( + const std::string& name) const { + return impl->named_events.find(name); +} + void KernelCore::AddNamedPort(std::string name, SharedPtr port) { impl->named_ports.emplace(std::move(name), std::move(port)); } diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index ea00c89f5..f12d061eb 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -20,6 +20,7 @@ namespace Kernel { class ClientPort; class HandleTable; class Process; +class ReadableEvent; class ResourceLimit; class Thread; class Timer; @@ -27,6 +28,7 @@ class Timer; /// Represents a single instance of the kernel. class KernelCore { private: + using NamedEventTable = std::unordered_map>; using NamedPortTable = std::unordered_map>; public: @@ -66,6 +68,15 @@ public: /// Retrieves a const pointer to the current process. const Process* CurrentProcess() const; + /// Adds an event to the named event table + void AddNamedEvent(std::string name, SharedPtr event); + + /// Finds an event within the named event table wit the given name. + NamedEventTable::iterator FindNamedEvent(const std::string& name); + + /// Finds an event within the named event table wit the given name. + NamedEventTable::const_iterator FindNamedEvent(const std::string& name) const; + /// Adds a port to the named port table void AddNamedPort(std::string name, SharedPtr port); -- cgit v1.2.3 From a56fc84e7a116681373ab9157193d2b8ae0f29af Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Mon, 26 Nov 2018 18:32:52 -0500 Subject: hle_ipc: Use event pair for SleepClientThread --- src/core/hle/kernel/hle_ipc.cpp | 27 +++++++++++++-------------- src/core/hle/kernel/hle_ipc.h | 14 +++++++++----- 2 files changed, 22 insertions(+), 19 deletions(-) diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp index 68d5376cb..2ffdb2f5b 100644 --- a/src/core/hle/kernel/hle_ipc.cpp +++ b/src/core/hle/kernel/hle_ipc.cpp @@ -15,13 +15,14 @@ #include "common/logging/log.h" #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" #include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/hle_ipc.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/object.h" #include "core/hle/kernel/process.h" +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/server_session.h" +#include "core/hle/kernel/writable_event.h" #include "core/memory.h" namespace Kernel { @@ -36,11 +37,9 @@ void SessionRequestHandler::ClientDisconnected(const SharedPtr& s boost::range::remove_erase(connected_sessions, server_session); } -SharedPtr HLERequestContext::SleepClientThread(SharedPtr thread, - const std::string& reason, u64 timeout, - WakeupCallback&& callback, - Kernel::SharedPtr event) { - +SharedPtr HLERequestContext::SleepClientThread( + SharedPtr thread, const std::string& reason, u64 timeout, WakeupCallback&& callback, + SharedPtr writable_event, SharedPtr readable_event) { // Put the client thread to sleep until the wait event is signaled or the timeout expires. thread->SetWakeupCallback([context = *this, callback]( ThreadWakeupReason reason, SharedPtr thread, @@ -51,23 +50,23 @@ SharedPtr HLERequestContext::SleepClientThread(SharedPtr thread, return true; }); - if (!event) { + auto& kernel = Core::System::GetInstance().Kernel(); + if (!writable_event || !readable_event) { // Create event if not provided - auto& kernel = Core::System::GetInstance().Kernel(); - event = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason); + std::tie(writable_event, readable_event) = WritableEvent::CreateEventPair( + kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason); } - event->Clear(); + writable_event->Clear(); thread->SetStatus(ThreadStatus::WaitHLEEvent); - thread->SetWaitObjects({event}); - event->AddWaitingThread(thread); + thread->SetWaitObjects({readable_event}); + readable_event->AddWaitingThread(thread); if (timeout > 0) { thread->WakeAfterDelay(timeout); } - return event; + return writable_event; } HLERequestContext::HLERequestContext(SharedPtr server_session) diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h index a38e34b74..557940f11 100644 --- a/src/core/hle/kernel/hle_ipc.h +++ b/src/core/hle/kernel/hle_ipc.h @@ -24,10 +24,11 @@ class ServiceFrameworkBase; namespace Kernel { class Domain; -class Event; class HandleTable; class HLERequestContext; class Process; +class ReadableEvent; +class WritableEvent; /** * Interface implemented by HLE Session handlers. @@ -119,12 +120,15 @@ public: * @param callback Callback to be invoked when the thread is resumed. This callback must write * the entire command response once again, regardless of the state of it before this function * was called. - * @param event Event to use to wake up the thread. If unspecified, an event will be created. + * @param writable_event Event to use to wake up the thread. If unspecified, an event will be + * created. + * @param readable_event Event to be bound to the thread to wake up upon. * @returns Event that when signaled will resume the thread and call the callback function. */ - SharedPtr SleepClientThread(SharedPtr thread, const std::string& reason, - u64 timeout, WakeupCallback&& callback, - Kernel::SharedPtr event = nullptr); + SharedPtr SleepClientThread(SharedPtr thread, const std::string& reason, + u64 timeout, WakeupCallback&& callback, + SharedPtr writable_event = nullptr, + SharedPtr readable_event = nullptr); /// Populates this context with data from the requesting process/thread. ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table, -- cgit v1.2.3 From ff610103b58b3e0dd39fafb539a1cc0bc0fae577 Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Mon, 26 Nov 2018 18:34:07 -0500 Subject: core: Port all current usages of Event to Readable/WritableEvent --- src/audio_core/audio_renderer.cpp | 4 +- src/audio_core/audio_renderer.h | 7 ++-- src/core/hle/kernel/svc.cpp | 11 ++--- src/core/hle/service/am/am.cpp | 38 +++++++++-------- src/core/hle/service/am/am.h | 16 +++---- src/core/hle/service/am/applets/applets.cpp | 31 ++++++++------ src/core/hle/service/am/applets/applets.h | 17 ++++---- src/core/hle/service/aoc/aoc_u.cpp | 13 ++++-- src/core/hle/service/aoc/aoc_u.h | 6 ++- src/core/hle/service/audio/audout_u.cpp | 14 ++++--- src/core/hle/service/audio/audren_u.cpp | 24 +++++++---- src/core/hle/service/btdrv/btdrv.cpp | 16 ++++--- src/core/hle/service/btm/btm.cpp | 55 +++++++++++++++---------- src/core/hle/service/hid/controllers/npad.cpp | 14 ++++--- src/core/hle/service/hid/controllers/npad.h | 11 +++-- src/core/hle/service/hid/hid.cpp | 3 +- src/core/hle/service/nfp/nfp.cpp | 35 ++++++++++------ src/core/hle/service/nfp/nfp.h | 10 +++-- src/core/hle/service/nifm/nifm.cpp | 18 +++++--- src/core/hle/service/nim/nim.cpp | 16 ++++--- src/core/hle/service/nvdrv/interface.cpp | 11 +++-- src/core/hle/service/nvdrv/interface.h | 7 +++- src/core/hle/service/nvflinger/buffer_queue.cpp | 17 +++++++- src/core/hle/service/nvflinger/buffer_queue.h | 15 ++++--- src/core/hle/service/nvflinger/nvflinger.cpp | 13 ++++-- src/core/hle/service/nvflinger/nvflinger.h | 11 +++-- src/core/hle/service/vi/vi.cpp | 5 ++- src/yuzu/debugger/wait_tree.cpp | 9 ++-- src/yuzu/debugger/wait_tree.h | 4 +- 29 files changed, 287 insertions(+), 164 deletions(-) diff --git a/src/audio_core/audio_renderer.cpp b/src/audio_core/audio_renderer.cpp index 23e5d3f10..2e59894ab 100644 --- a/src/audio_core/audio_renderer.cpp +++ b/src/audio_core/audio_renderer.cpp @@ -8,7 +8,7 @@ #include "audio_core/codec.h" #include "common/assert.h" #include "common/logging/log.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/writable_event.h" #include "core/memory.h" namespace AudioCore { @@ -72,7 +72,7 @@ private: EffectInStatus info{}; }; AudioRenderer::AudioRenderer(AudioRendererParameter params, - Kernel::SharedPtr buffer_event) + Kernel::SharedPtr buffer_event) : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count), effects(params.effect_count) { diff --git a/src/audio_core/audio_renderer.h b/src/audio_core/audio_renderer.h index 71ba4be40..7826881bf 100644 --- a/src/audio_core/audio_renderer.h +++ b/src/audio_core/audio_renderer.h @@ -15,7 +15,7 @@ #include "core/hle/kernel/object.h" namespace Kernel { -class Event; +class WritableEvent; } namespace AudioCore { @@ -208,7 +208,8 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size class AudioRenderer { public: - AudioRenderer(AudioRendererParameter params, Kernel::SharedPtr buffer_event); + AudioRenderer(AudioRendererParameter params, + Kernel::SharedPtr buffer_event); ~AudioRenderer(); std::vector UpdateAudioRenderer(const std::vector& input_params); @@ -224,7 +225,7 @@ private: class VoiceState; AudioRendererParameter worker_params; - Kernel::SharedPtr buffer_event; + Kernel::SharedPtr buffer_event; std::vector voices; std::vector effects; std::unique_ptr audio_out; diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp index 5e9660a48..85a9c50fb 100644 --- a/src/core/hle/kernel/svc.cpp +++ b/src/core/hle/kernel/svc.cpp @@ -20,17 +20,18 @@ #include "core/hle/kernel/address_arbiter.h" #include "core/hle/kernel/client_port.h" #include "core/hle/kernel/client_session.h" -#include "core/hle/kernel/event.h" #include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/mutex.h" #include "core/hle/kernel/process.h" +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/resource_limit.h" #include "core/hle/kernel/scheduler.h" #include "core/hle/kernel/shared_memory.h" #include "core/hle/kernel/svc.h" #include "core/hle/kernel/svc_wrap.h" #include "core/hle/kernel/thread.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/lock.h" #include "core/hle/result.h" #include "core/hle/service/service.h" @@ -1361,11 +1362,11 @@ static ResultCode ResetSignal(Handle handle) { LOG_DEBUG(Kernel_SVC, "called handle 0x{:08X}", handle); const auto& handle_table = Core::CurrentProcess()->GetHandleTable(); - auto event = handle_table.Get(handle); + auto event = handle_table.Get(handle); ASSERT(event != nullptr); - event->Clear(); + event->PromoteToWritable()->Clear(); return RESULT_SUCCESS; } @@ -1524,13 +1525,13 @@ static ResultCode ClearEvent(Handle handle) { LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle); const auto& handle_table = Core::CurrentProcess()->GetHandleTable(); - SharedPtr evt = handle_table.Get(handle); + SharedPtr evt = handle_table.Get(handle); if (evt == nullptr) { LOG_ERROR(Kernel_SVC, "Event handle does not exist, handle=0x{:08X}", handle); return ERR_INVALID_HANDLE; } - evt->Clear(); + evt->PromoteToWritable()->Clear(); return RESULT_SUCCESS; } diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp index d595c37b0..43c91e521 100644 --- a/src/core/hle/service/am/am.cpp +++ b/src/core/hle/service/am/am.cpp @@ -9,9 +9,11 @@ #include "audio_core/audio_renderer.h" #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/kernel.h" #include "core/hle/kernel/process.h" +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/shared_memory.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/acc/profile_manager.h" #include "core/hle/service/am/am.h" #include "core/hle/service/am/applet_ae.h" @@ -208,8 +210,8 @@ ISelfController::ISelfController(std::shared_ptr nvflinger RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - launchable_event = - Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent"); + launchable_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent"); } ISelfController::~ISelfController() = default; @@ -299,8 +301,7 @@ void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(launchable_event); -} + rb.PushCopyObjects(event->second); void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_AM, "(STUBBED) called"); @@ -348,20 +349,26 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c AppletMessageQueue::AppletMessageQueue() { auto& kernel = Core::System::GetInstance().Kernel(); - on_new_message = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, - "AMMessageQueue:OnMessageRecieved"); - on_operation_mode_changed = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, - "AMMessageQueue:OperationModeChanged"); + on_new_message = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::Sticky, "AMMessageQueue:OnMessageRecieved"); + on_operation_mode_changed = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "AMMessageQueue:OperationModeChanged"); } AppletMessageQueue::~AppletMessageQueue() = default; -const Kernel::SharedPtr& AppletMessageQueue::GetMesssageRecieveEvent() const { - return on_new_message; +const Kernel::SharedPtr& AppletMessageQueue::GetMesssageRecieveEvent() + const { + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OnMessageRecieved")}; + return event->second; } -const Kernel::SharedPtr& AppletMessageQueue::GetOperationModeChangedEvent() const { - return on_operation_mode_changed; +const Kernel::SharedPtr& AppletMessageQueue::GetOperationModeChangedEvent() + const { + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OperationModeChanged")}; + return event->second; } void AppletMessageQueue::PushMessage(AppletMessage msg) { @@ -426,9 +433,6 @@ ICommonStateGetter::ICommonStateGetter(std::shared_ptr msg_q // clang-format on RegisterHandlers(functions); - - auto& kernel = Core::System::GetInstance().Kernel(); - event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "ICommonStateGetter:Event"); } ICommonStateGetter::~ICommonStateGetter() = default; @@ -564,8 +568,8 @@ private: void GetAppletStateChangedEvent(Kernel::HLERequestContext& ctx) { LOG_DEBUG(Service_AM, "called"); + applet->GetBroker().SignalStateChanged(); const auto event = applet->GetBroker().GetStateChangedEvent(); - event->Signal(); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); diff --git a/src/core/hle/service/am/am.h b/src/core/hle/service/am/am.h index 44c1bcde5..ef90b0702 100644 --- a/src/core/hle/service/am/am.h +++ b/src/core/hle/service/am/am.h @@ -9,8 +9,9 @@ #include "core/hle/service/service.h" namespace Kernel { -class Event; -} +class ReadableEvent; +class WritableEvent; +} // namespace Kernel namespace Service { namespace NVFlinger { @@ -52,8 +53,8 @@ public: AppletMessageQueue(); ~AppletMessageQueue(); - const Kernel::SharedPtr& GetMesssageRecieveEvent() const; - const Kernel::SharedPtr& GetOperationModeChangedEvent() const; + const Kernel::SharedPtr& GetMesssageRecieveEvent() const; + const Kernel::SharedPtr& GetOperationModeChangedEvent() const; void PushMessage(AppletMessage msg); AppletMessage PopMessage(); std::size_t GetMessageCount() const; @@ -61,8 +62,8 @@ public: private: std::queue messages; - Kernel::SharedPtr on_new_message; - Kernel::SharedPtr on_operation_mode_changed; + Kernel::SharedPtr on_new_message; + Kernel::SharedPtr on_operation_mode_changed; }; class IWindowController final : public ServiceFramework { @@ -122,7 +123,7 @@ private: void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx); std::shared_ptr nvflinger; - Kernel::SharedPtr launchable_event; + Kernel::SharedPtr launchable_event; u32 idle_time_detection_extension = 0; }; @@ -151,7 +152,6 @@ private: void GetBootMode(Kernel::HLERequestContext& ctx); void GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx); - Kernel::SharedPtr event; std::shared_ptr msg_queue; }; diff --git a/src/core/hle/service/am/applets/applets.cpp b/src/core/hle/service/am/applets/applets.cpp index becbadd06..494205322 100644 --- a/src/core/hle/service/am/applets/applets.cpp +++ b/src/core/hle/service/am/applets/applets.cpp @@ -5,8 +5,9 @@ #include #include "common/assert.h" #include "core/core.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/server_port.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/am/am.h" #include "core/hle/service/am/applets/applets.h" @@ -14,11 +15,11 @@ namespace Service::AM::Applets { AppletDataBroker::AppletDataBroker() { auto& kernel = Core::System::GetInstance().Kernel(); - state_changed_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, - "ILibraryAppletAccessor:StateChangedEvent"); - pop_out_data_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, - "ILibraryAppletAccessor:PopDataOutEvent"); - pop_interactive_out_data_event = Kernel::Event::Create( + state_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:StateChangedEvent"); + pop_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopDataOutEvent"); + pop_interactive_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair( kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopInteractiveDataOutEvent"); } @@ -82,16 +83,22 @@ void AppletDataBroker::SignalStateChanged() const { state_changed_event->Signal(); } -Kernel::SharedPtr AppletDataBroker::GetNormalDataEvent() const { - return pop_out_data_event; +Kernel::SharedPtr AppletDataBroker::GetNormalDataEvent() const { + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( + "ILibraryAppletAccessor:PopDataOutEvent")}; + return event->second; } -Kernel::SharedPtr AppletDataBroker::GetInteractiveDataEvent() const { - return pop_interactive_out_data_event; +Kernel::SharedPtr AppletDataBroker::GetInteractiveDataEvent() const { + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( + "ILibraryAppletAccessor:PopInteractiveDataOutEvent")}; + return event->second; } -Kernel::SharedPtr AppletDataBroker::GetStateChangedEvent() const { - return state_changed_event; +Kernel::SharedPtr AppletDataBroker::GetStateChangedEvent() const { + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( + "ILibraryAppletAccessor:StateChangedEvent")}; + return event->second; } Applet::Applet() = default; diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h index f65ea119c..5cd6232cc 100644 --- a/src/core/hle/service/am/applets/applets.h +++ b/src/core/hle/service/am/applets/applets.h @@ -12,8 +12,9 @@ union ResultCode; namespace Kernel { -class Event; -} +class ReadableEvent; +class WritableEvent; +} // namespace Kernel namespace Service::AM { @@ -40,9 +41,9 @@ public: void SignalStateChanged() const; - Kernel::SharedPtr GetNormalDataEvent() const; - Kernel::SharedPtr GetInteractiveDataEvent() const; - Kernel::SharedPtr GetStateChangedEvent() const; + Kernel::SharedPtr GetNormalDataEvent() const; + Kernel::SharedPtr GetInteractiveDataEvent() const; + Kernel::SharedPtr GetStateChangedEvent() const; private: // Queues are named from applet's perspective @@ -59,13 +60,13 @@ private: // PopInteractiveDataToGame and PushInteractiveDataFromApplet std::queue> out_interactive_channel; - Kernel::SharedPtr state_changed_event; + Kernel::SharedPtr state_changed_event; // Signaled on PushNormalDataFromApplet - Kernel::SharedPtr pop_out_data_event; + Kernel::SharedPtr pop_out_data_event; // Signaled on PushInteractiveDataFromApplet - Kernel::SharedPtr pop_interactive_out_data_event; + Kernel::SharedPtr pop_interactive_out_data_event; }; class Applet { diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp index bacf19de2..a89f99dc7 100644 --- a/src/core/hle/service/aoc/aoc_u.cpp +++ b/src/core/hle/service/aoc/aoc_u.cpp @@ -13,8 +13,10 @@ #include "core/file_sys/patch_manager.h" #include "core/file_sys/registered_cache.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/kernel.h" #include "core/hle/kernel/process.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/aoc/aoc_u.h" #include "core/hle/service/filesystem/filesystem.h" #include "core/loader/loader.h" @@ -61,8 +63,8 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - aoc_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, - "GetAddOnContentListChanged:Event"); + aoc_change_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::Sticky, "GetAddOnContentListChanged:Event"); } AOC_U::~AOC_U() = default; @@ -142,9 +144,12 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) { void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_AOC, "(STUBBED) called"); + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("GetAddOnContentListChanged:Event")}; + IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(aoc_change_event); + rb.PushCopyObjects(event->second); } void InstallInterfaces(SM::ServiceManager& service_manager) { diff --git a/src/core/hle/service/aoc/aoc_u.h b/src/core/hle/service/aoc/aoc_u.h index 68d94fdaa..f32a757aa 100644 --- a/src/core/hle/service/aoc/aoc_u.h +++ b/src/core/hle/service/aoc/aoc_u.h @@ -6,6 +6,10 @@ #include "core/hle/service/service.h" +namespace Kernel { +class WritableEvent; +} + namespace Service::AOC { class AOC_U final : public ServiceFramework { @@ -21,7 +25,7 @@ private: void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx); std::vector add_on_content; - Kernel::SharedPtr aoc_change_event; + Kernel::SharedPtr aoc_change_event; }; /// Registers all AOC services with the specified service manager. diff --git a/src/core/hle/service/audio/audout_u.cpp b/src/core/hle/service/audio/audout_u.cpp index 2ee9bc273..b5012e579 100644 --- a/src/core/hle/service/audio/audout_u.cpp +++ b/src/core/hle/service/audio/audout_u.cpp @@ -13,8 +13,10 @@ #include "common/swap.h" #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" #include "core/hle/kernel/hle_ipc.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/audio/audout_u.h" #include "core/memory.h" @@ -67,8 +69,8 @@ public: // This is the event handle used to check if the audio buffer was released auto& kernel = Core::System::GetInstance().Kernel(); - buffer_event = - Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased"); + buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased"); stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count, std::move(unique_name), [=]() { buffer_event->Signal(); }); @@ -121,7 +123,9 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(buffer_event); + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleased")}; + rb.PushCopyObjects(event->second); } void AppendAudioOutBufferImpl(Kernel::HLERequestContext& ctx) { @@ -188,7 +192,7 @@ private: AudoutParams audio_params{}; /// This is the evend handle used to check if the audio buffer was released - Kernel::SharedPtr buffer_event; + Kernel::SharedPtr buffer_event; }; void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) { diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp index 1c418a9bb..9b7f7b201 100644 --- a/src/core/hle/service/audio/audren_u.cpp +++ b/src/core/hle/service/audio/audren_u.cpp @@ -12,8 +12,10 @@ #include "common/logging/log.h" #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" #include "core/hle/kernel/hle_ipc.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/audio/audren_u.h" namespace Service::Audio { @@ -41,8 +43,8 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - system_event = - Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent"); + system_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent"); renderer = std::make_unique(audren_params, system_event); } @@ -112,7 +114,9 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(system_event); + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IAudioRenderer:SystemEvent")}; + rb.PushCopyObjects(event->second); } void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) { @@ -135,7 +139,7 @@ private: rb.Push(rendering_time_limit_percent); } - Kernel::SharedPtr system_event; + Kernel::SharedPtr system_event; std::unique_ptr renderer; u32 rendering_time_limit_percent = 100; }; @@ -162,8 +166,8 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - buffer_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, - "IAudioOutBufferReleasedEvent"); + buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IAudioOutBufferReleasedEvent"); } private: @@ -211,7 +215,9 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(buffer_event); + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleasedEvent")}; + rb.PushCopyObjects(event->second); } void GetActiveChannelCount(Kernel::HLERequestContext& ctx) { @@ -222,7 +228,7 @@ private: rb.Push(1); } - Kernel::SharedPtr buffer_event; + Kernel::SharedPtr buffer_event; }; // namespace Audio diff --git a/src/core/hle/service/btdrv/btdrv.cpp b/src/core/hle/service/btdrv/btdrv.cpp index 2eadcdd05..04c78e81a 100644 --- a/src/core/hle/service/btdrv/btdrv.cpp +++ b/src/core/hle/service/btdrv/btdrv.cpp @@ -4,8 +4,10 @@ #include "common/logging/log.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" #include "core/hle/kernel/hle_ipc.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/btdrv/btdrv.h" #include "core/hle/service/service.h" #include "core/hle/service/sm/sm.h" @@ -30,20 +32,22 @@ public: }; // clang-format on RegisterHandlers(functions); + + auto& kernel = Core::System::GetInstance().Kernel(); + register_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent"); } private: void RegisterEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); - auto& kernel = Core::System::GetInstance().Kernel(); - register_event = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(register_event); + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("BT:RegisterEvent")}; + rb.PushCopyObjects(event->second); } - Kernel::SharedPtr register_event; + Kernel::SharedPtr register_event; }; class BtDrv final : public ServiceFramework { diff --git a/src/core/hle/service/btm/btm.cpp b/src/core/hle/service/btm/btm.cpp index 463a79351..3ee298161 100644 --- a/src/core/hle/service/btm/btm.cpp +++ b/src/core/hle/service/btm/btm.cpp @@ -6,8 +6,10 @@ #include "common/logging/log.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" #include "core/hle/kernel/hle_ipc.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/btm/btm.h" #include "core/hle/service/service.h" @@ -53,53 +55,64 @@ public: }; // clang-format on RegisterHandlers(functions); + + auto& kernel = Core::System::GetInstance().Kernel(); + scan_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent"); + connection_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConnectionEvent"); + service_discovery = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery"); + config_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent"); } private: void GetScanEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); - auto& kernel = Core::System::GetInstance().Kernel(); - scan_event = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(scan_event); + + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ScanEvent")}; + rb.PushCopyObjects(event->second); } void GetConnectionEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); - auto& kernel = Core::System::GetInstance().Kernel(); - connection_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, - "IBtmUserCore:ConnectionEvent"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(connection_event); + + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConnectionEvent")}; + rb.PushCopyObjects(event->second); } void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); - auto& kernel = Core::System::GetInstance().Kernel(); - service_discovery = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(service_discovery); + + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:Discovery")}; + rb.PushCopyObjects(event->second); } void GetConfigEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); - auto& kernel = Core::System::GetInstance().Kernel(); - config_event = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(config_event); + + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConfigEvent")}; + rb.PushCopyObjects(event->second); } - Kernel::SharedPtr scan_event; - Kernel::SharedPtr connection_event; - Kernel::SharedPtr service_discovery; - Kernel::SharedPtr config_event; + + Kernel::SharedPtr scan_event; + Kernel::SharedPtr connection_event; + Kernel::SharedPtr service_discovery; + Kernel::SharedPtr config_event; }; class BTM_USR final : public ServiceFramework { diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp index 22e87a50a..df39a6dc4 100644 --- a/src/core/hle/service/hid/controllers/npad.cpp +++ b/src/core/hle/service/hid/controllers/npad.cpp @@ -12,7 +12,9 @@ #include "core/core.h" #include "core/core_timing.h" #include "core/frontend/input.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/hid/controllers/npad.h" #include "core/settings.h" @@ -167,8 +169,8 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) { void Controller_NPad::OnInit() { auto& kernel = Core::System::GetInstance().Kernel(); - styleset_changed_event = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged"); + styleset_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged"); if (!IsControllerActivated()) { return; @@ -538,11 +540,13 @@ void Controller_NPad::VibrateController(const std::vector& controller_ids, last_processed_vibration = vibrations.back(); } -Kernel::SharedPtr Controller_NPad::GetStyleSetChangedEvent() const { +Kernel::SharedPtr Controller_NPad::GetStyleSetChangedEvent() const { // TODO(ogniK): Figure out the best time to signal this event. This event seems that it should // be signalled at least once, and signaled after a new controller is connected? styleset_changed_event->Signal(); - return styleset_changed_event; + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("npad:NpadStyleSetChanged")}; + return event->second; } Controller_NPad::Vibration Controller_NPad::GetLastVibration() const { diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h index abff6544d..c960d0f57 100644 --- a/src/core/hle/service/hid/controllers/npad.h +++ b/src/core/hle/service/hid/controllers/npad.h @@ -8,10 +8,15 @@ #include "common/bit_field.h" #include "common/common_types.h" #include "core/frontend/input.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/object.h" #include "core/hle/service/hid/controllers/controller_base.h" #include "core/settings.h" +namespace Kernel { +class ReadableEvent; +class WritableEvent; +} // namespace Kernel + namespace Service::HID { constexpr u32 NPAD_HANDHELD = 32; @@ -108,7 +113,7 @@ public: void VibrateController(const std::vector& controller_ids, const std::vector& vibrations); - Kernel::SharedPtr GetStyleSetChangedEvent() const; + Kernel::SharedPtr GetStyleSetChangedEvent() const; Vibration GetLastVibration() const; void AddNewController(NPadControllerType controller); @@ -303,7 +308,7 @@ private: sticks; std::vector supported_npad_id_types{}; NpadHoldType hold_type{NpadHoldType::Vertical}; - Kernel::SharedPtr styleset_changed_event; + Kernel::SharedPtr styleset_changed_event; Vibration last_processed_vibration{}; std::array connected_controllers{}; bool can_controllers_vibrate{true}; diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index 46496e9bb..2ec38c726 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -13,8 +13,9 @@ #include "core/hle/ipc_helpers.h" #include "core/hle/kernel/client_port.h" #include "core/hle/kernel/client_session.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/shared_memory.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/hid/hid.h" #include "core/hle/service/hid/irs.h" #include "core/hle/service/hid/xcd.h" diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp index ff9170c24..75c605364 100644 --- a/src/core/hle/service/nfp/nfp.cpp +++ b/src/core/hle/service/nfp/nfp.cpp @@ -7,7 +7,9 @@ #include "common/logging/log.h" #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/lock.h" #include "core/hle/service/hid/hid.h" #include "core/hle/service/nfp/nfp.h" @@ -23,8 +25,8 @@ constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP, Module::Interface::Interface(std::shared_ptr module, const char* name) : ServiceFramework(name), module(std::move(module)) { auto& kernel = Core::System::GetInstance().Kernel(); - nfc_tag_load = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected"); + nfc_tag_load = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected"); } Module::Interface::~Interface() = default; @@ -63,10 +65,10 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - deactivate_event = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent"); - availability_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, - "IUser:AvailabilityChangeEvent"); + deactivate_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent"); + availability_change_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IUser:AvailabilityChangeEvent"); } private: @@ -164,7 +166,10 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(deactivate_event); + + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IUser:DeactivateEvent")}; + rb.PushCopyObjects(event->second); } void StopDetection(Kernel::HLERequestContext& ctx) { @@ -264,7 +269,9 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(availability_change_event); + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("IUser:AvailabilityChangeEvent")}; + rb.PushCopyObjects(event->second); } void GetRegisterInfo(Kernel::HLERequestContext& ctx) { @@ -319,8 +326,8 @@ private: const u32 npad_id{0}; // Player 1 controller State state{State::NonInitialized}; DeviceState device_state{DeviceState::Initialized}; - Kernel::SharedPtr deactivate_event; - Kernel::SharedPtr availability_change_event; + Kernel::SharedPtr deactivate_event; + Kernel::SharedPtr availability_change_event; const Module::Interface& nfp_interface; }; @@ -342,8 +349,10 @@ bool Module::Interface::LoadAmiibo(const std::vector& buffer) { nfc_tag_load->Signal(); return true; } -const Kernel::SharedPtr& Module::Interface::GetNFCEvent() const { - return nfc_tag_load; + +const Kernel::SharedPtr& Module::Interface::GetNFCEvent() const { + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("IUser:NFCTagDetected")}; + return event->second; } const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const { return amiibo; diff --git a/src/core/hle/service/nfp/nfp.h b/src/core/hle/service/nfp/nfp.h index 5c0ae8a54..0ab1ca997 100644 --- a/src/core/hle/service/nfp/nfp.h +++ b/src/core/hle/service/nfp/nfp.h @@ -6,9 +6,13 @@ #include #include -#include "core/hle/kernel/event.h" #include "core/hle/service/service.h" +namespace Kernel { +class ReadableEvent; +class WritableEvent; +} // namespace Kernel + namespace Service::NFP { class Module final { @@ -33,11 +37,11 @@ public: void CreateUserInterface(Kernel::HLERequestContext& ctx); bool LoadAmiibo(const std::vector& buffer); - const Kernel::SharedPtr& GetNFCEvent() const; + const Kernel::SharedPtr& GetNFCEvent() const; const AmiiboFile& GetAmiiboBuffer() const; private: - Kernel::SharedPtr nfc_tag_load{}; + Kernel::SharedPtr nfc_tag_load{}; AmiiboFile amiibo{}; protected: diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp index dee391201..80a66bce3 100644 --- a/src/core/hle/service/nifm/nifm.cpp +++ b/src/core/hle/service/nifm/nifm.cpp @@ -4,7 +4,9 @@ #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/nifm/nifm.h" #include "core/hle/service/service.h" @@ -56,8 +58,10 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - event1 = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IRequest:Event1"); - event2 = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IRequest:Event2"); + event1 = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IRequest:Event1"); + event2 = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "IRequest:Event2"); } private: @@ -88,7 +92,11 @@ private: IPC::ResponseBuilder rb{ctx, 2, 2}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(event1, event2); + + const auto& event1{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event1")}; + const auto& event2{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event2")}; + + rb.PushCopyObjects(event1->second, event2->second); } void Cancel(Kernel::HLERequestContext& ctx) { @@ -105,7 +113,7 @@ private: rb.Push(RESULT_SUCCESS); } - Kernel::SharedPtr event1, event2; + Kernel::SharedPtr event1, event2; }; class INetworkProfile final : public ServiceFramework { diff --git a/src/core/hle/service/nim/nim.cpp b/src/core/hle/service/nim/nim.cpp index 1bbccd444..d181a781c 100644 --- a/src/core/hle/service/nim/nim.cpp +++ b/src/core/hle/service/nim/nim.cpp @@ -6,7 +6,9 @@ #include #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/nim/nim.h" #include "core/hle/service/service.h" #include "core/hle/service/sm/sm.h" @@ -138,13 +140,13 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - finished_event = - Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, - "IEnsureNetworkClockAvailabilityService:FinishEvent"); + finished_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, + "IEnsureNetworkClockAvailabilityService:FinishEvent"); } private: - Kernel::SharedPtr finished_event; + Kernel::SharedPtr finished_event; void StartTask(Kernel::HLERequestContext& ctx) { // No need to connect to the internet, just finish the task straight away. @@ -160,7 +162,9 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(finished_event); + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( + "IEnsureNetworkClockAvailabilityService:FinishEvent")}; + rb.PushCopyObjects(event->second); } void GetResult(Kernel::HLERequestContext& ctx) { diff --git a/src/core/hle/service/nvdrv/interface.cpp b/src/core/hle/service/nvdrv/interface.cpp index ff76e0524..3d89b4020 100644 --- a/src/core/hle/service/nvdrv/interface.cpp +++ b/src/core/hle/service/nvdrv/interface.cpp @@ -6,7 +6,9 @@ #include "common/logging/log.h" #include "core/core.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/nvdrv/interface.h" #include "core/hle/service/nvdrv/nvdrv.h" @@ -69,7 +71,9 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 3, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(query_event); + + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("NVDRV::query_event")}; + rb.PushCopyObjects(event->second); rb.Push(0); } @@ -127,7 +131,8 @@ NVDRV::NVDRV(std::shared_ptr nvdrv, const char* name) RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - query_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "NVDRV::query_event"); + query_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::OneShot, "NVDRV::query_event"); } NVDRV::~NVDRV() = default; diff --git a/src/core/hle/service/nvdrv/interface.h b/src/core/hle/service/nvdrv/interface.h index 5a1e4baa7..a27252038 100644 --- a/src/core/hle/service/nvdrv/interface.h +++ b/src/core/hle/service/nvdrv/interface.h @@ -5,10 +5,13 @@ #pragma once #include -#include "core/hle/kernel/event.h" #include "core/hle/service/nvdrv/nvdrv.h" #include "core/hle/service/service.h" +namespace Kernel { +class WritableEvent; +} + namespace Service::Nvidia { class NVDRV final : public ServiceFramework { @@ -31,7 +34,7 @@ private: u64 pid{}; - Kernel::SharedPtr query_event; + Kernel::SharedPtr query_event; }; } // namespace Service::Nvidia diff --git a/src/core/hle/service/nvflinger/buffer_queue.cpp b/src/core/hle/service/nvflinger/buffer_queue.cpp index 172a1a441..7b07750b5 100644 --- a/src/core/hle/service/nvflinger/buffer_queue.cpp +++ b/src/core/hle/service/nvflinger/buffer_queue.cpp @@ -7,14 +7,17 @@ #include "common/assert.h" #include "common/logging/log.h" #include "core/core.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/nvflinger/buffer_queue.h" namespace Service::NVFlinger { BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) { auto& kernel = Core::System::GetInstance().Kernel(); - buffer_wait_event = - Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "BufferQueue NativeHandle"); + buffer_wait_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::Sticky, "BufferQueue NativeHandle"); } BufferQueue::~BufferQueue() = default; @@ -104,4 +107,14 @@ u32 BufferQueue::Query(QueryType type) { return 0; } +Kernel::SharedPtr BufferQueue::GetWritableBufferWaitEvent() const { + return buffer_wait_event; +} + +Kernel::SharedPtr BufferQueue::GetBufferWaitEvent() const { + const auto& event{ + Core::System::GetInstance().Kernel().FindNamedEvent("BufferQueue NativeHandle")}; + return event->second; +} + } // namespace Service::NVFlinger diff --git a/src/core/hle/service/nvflinger/buffer_queue.h b/src/core/hle/service/nvflinger/buffer_queue.h index 8cff5eb71..8b2a2b7de 100644 --- a/src/core/hle/service/nvflinger/buffer_queue.h +++ b/src/core/hle/service/nvflinger/buffer_queue.h @@ -10,12 +10,17 @@ #include "common/common_funcs.h" #include "common/math_util.h" #include "common/swap.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/object.h" namespace CoreTiming { struct EventType; } +namespace Kernel { +class ReadableEvent; +class WritableEvent; +} // namespace Kernel + namespace Service::NVFlinger { struct IGBPBuffer { @@ -86,16 +91,16 @@ public: return id; } - Kernel::SharedPtr GetBufferWaitEvent() const { - return buffer_wait_event; - } + Kernel::SharedPtr GetWritableBufferWaitEvent() const; + + Kernel::SharedPtr GetBufferWaitEvent() const; private: u32 id; u64 layer_id; std::vector queue; - Kernel::SharedPtr buffer_wait_event; + Kernel::SharedPtr buffer_wait_event; }; } // namespace Service::NVFlinger diff --git a/src/core/hle/service/nvflinger/nvflinger.cpp b/src/core/hle/service/nvflinger/nvflinger.cpp index 214e6d1b3..2a329cb8e 100644 --- a/src/core/hle/service/nvflinger/nvflinger.cpp +++ b/src/core/hle/service/nvflinger/nvflinger.cpp @@ -13,6 +13,9 @@ #include "core/core.h" #include "core/core_timing.h" #include "core/core_timing_util.h" +#include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h" #include "core/hle/service/nvdrv/nvdrv.h" #include "core/hle/service/nvflinger/buffer_queue.h" @@ -83,9 +86,10 @@ u32 NVFlinger::GetBufferQueueId(u64 display_id, u64 layer_id) { return layer.buffer_queue->GetId(); } -Kernel::SharedPtr NVFlinger::GetVsyncEvent(u64 display_id) { - const auto& display = GetDisplay(display_id); - return display.vsync_event; +Kernel::SharedPtr NVFlinger::GetVsyncEvent(u64 display_id) { + const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( + fmt::format("Display VSync Event {}", display_id))}; + return event->second; } std::shared_ptr NVFlinger::GetBufferQueue(u32 id) const { @@ -164,7 +168,8 @@ Layer::~Layer() = default; Display::Display(u64 id, std::string name) : id(id), name(std::move(name)) { auto& kernel = Core::System::GetInstance().Kernel(); - vsync_event = Kernel::Event::Create(kernel, Kernel::ResetType::Pulse, "Display VSync Event"); + vsync_event = Kernel::WritableEvent::CreateRegisteredEventPair( + kernel, Kernel::ResetType::Pulse, fmt::format("Display VSync Event {}", id)); } Display::~Display() = default; diff --git a/src/core/hle/service/nvflinger/nvflinger.h b/src/core/hle/service/nvflinger/nvflinger.h index 3dc69e69b..1a9e74f35 100644 --- a/src/core/hle/service/nvflinger/nvflinger.h +++ b/src/core/hle/service/nvflinger/nvflinger.h @@ -10,12 +10,17 @@ #include #include "common/common_types.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/object.h" namespace CoreTiming { struct EventType; } +namespace Kernel { +class ReadableEvent; +class WritableEvent; +} // namespace Kernel + namespace Service::Nvidia { class Module; } @@ -40,7 +45,7 @@ struct Display { std::string name; std::vector layers; - Kernel::SharedPtr vsync_event; + Kernel::SharedPtr vsync_event; }; class NVFlinger final { @@ -61,7 +66,7 @@ public: u32 GetBufferQueueId(u64 display_id, u64 layer_id); /// Gets the vsync event for the specified display. - Kernel::SharedPtr GetVsyncEvent(u64 display_id); + Kernel::SharedPtr GetVsyncEvent(u64 display_id); /// Obtains a buffer queue identified by the id. std::shared_ptr GetBufferQueue(u32 id) const; diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp index 5120abfff..47beaf8f6 100644 --- a/src/core/hle/service/vi/vi.cpp +++ b/src/core/hle/service/vi/vi.cpp @@ -18,7 +18,8 @@ #include "common/swap.h" #include "core/core_timing.h" #include "core/hle/ipc_helpers.h" -#include "core/hle/kernel/event.h" +#include "core/hle/kernel/readable_event.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/nvdrv/nvdrv.h" #include "core/hle/service/nvflinger/buffer_queue.h" #include "core/hle/service/nvflinger/nvflinger.h" @@ -547,7 +548,7 @@ private: IPC::ResponseBuilder rb{ctx, 2}; rb.Push(RESULT_SUCCESS); }, - buffer_queue->GetBufferWaitEvent()); + buffer_queue->GetWritableBufferWaitEvent(), buffer_queue->GetBufferWaitEvent()); } } else if (transaction == TransactionId::RequestBuffer) { IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()}; diff --git a/src/yuzu/debugger/wait_tree.cpp b/src/yuzu/debugger/wait_tree.cpp index 0c831c9f4..797be6c4a 100644 --- a/src/yuzu/debugger/wait_tree.cpp +++ b/src/yuzu/debugger/wait_tree.cpp @@ -7,7 +7,6 @@ #include "common/assert.h" #include "core/core.h" -#include "core/hle/kernel/event.h" #include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/mutex.h" #include "core/hle/kernel/process.h" @@ -15,6 +14,7 @@ #include "core/hle/kernel/thread.h" #include "core/hle/kernel/timer.h" #include "core/hle/kernel/wait_object.h" +#include "core/hle/kernel/writable_event.h" #include "core/memory.h" WaitTreeItem::WaitTreeItem() = default; @@ -154,7 +154,7 @@ QString WaitTreeWaitObject::GetText() const { std::unique_ptr WaitTreeWaitObject::make(const Kernel::WaitObject& object) { switch (object.GetHandleType()) { case Kernel::HandleType::Event: - return std::make_unique(static_cast(object)); + return std::make_unique(static_cast(object)); case Kernel::HandleType::Timer: return std::make_unique(static_cast(object)); case Kernel::HandleType::Thread: @@ -332,7 +332,7 @@ std::vector> WaitTreeThread::GetChildren() const { return list; } -WaitTreeEvent::WaitTreeEvent(const Kernel::Event& object) : WaitTreeWaitObject(object) {} +WaitTreeEvent::WaitTreeEvent(const Kernel::WritableEvent& object) : WaitTreeWaitObject(object) {} WaitTreeEvent::~WaitTreeEvent() = default; std::vector> WaitTreeEvent::GetChildren() const { @@ -340,7 +340,8 @@ std::vector> WaitTreeEvent::GetChildren() const { list.push_back(std::make_unique( tr("reset type = %1") - .arg(GetResetTypeQString(static_cast(object).GetResetType())))); + .arg(GetResetTypeQString( + static_cast(object).GetResetType())))); return list; } diff --git a/src/yuzu/debugger/wait_tree.h b/src/yuzu/debugger/wait_tree.h index 331f89885..c0b6e0e7f 100644 --- a/src/yuzu/debugger/wait_tree.h +++ b/src/yuzu/debugger/wait_tree.h @@ -18,7 +18,7 @@ class EmuThread; namespace Kernel { class WaitObject; -class Event; +class WritableEvent; class Thread; class Timer; } // namespace Kernel @@ -144,7 +144,7 @@ public: class WaitTreeEvent : public WaitTreeWaitObject { Q_OBJECT public: - explicit WaitTreeEvent(const Kernel::Event& object); + explicit WaitTreeEvent(const Kernel::WritableEvent& object); ~WaitTreeEvent() override; std::vector> GetChildren() const override; -- cgit v1.2.3 From a342bcc9b130e9bd78720e09e04c92dcac8840d0 Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Tue, 27 Nov 2018 09:18:29 -0500 Subject: kernel/event: Reference ReadableEvent from WritableEvent --- src/core/hle/kernel/hle_ipc.cpp | 6 ++- src/core/hle/kernel/kernel.cpp | 17 -------- src/core/hle/kernel/kernel.h | 11 ----- src/core/hle/kernel/readable_event.cpp | 24 +++++------ src/core/hle/kernel/readable_event.h | 17 ++++---- src/core/hle/kernel/svc.cpp | 4 +- src/core/hle/kernel/writable_event.cpp | 57 ++++++------------------- src/core/hle/kernel/writable_event.h | 36 +++++----------- src/core/hle/service/am/am.cpp | 30 ++++++------- src/core/hle/service/am/am.h | 12 ++---- src/core/hle/service/am/applets/applets.cpp | 24 ++++------- src/core/hle/service/am/applets/applets.h | 6 +-- src/core/hle/service/aoc/aoc_u.cpp | 9 ++-- src/core/hle/service/aoc/aoc_u.h | 2 +- src/core/hle/service/audio/audout_u.cpp | 15 +++---- src/core/hle/service/audio/audren_u.cpp | 26 +++++------ src/core/hle/service/btdrv/btdrv.cpp | 10 ++--- src/core/hle/service/btm/btm.cpp | 43 ++++++++----------- src/core/hle/service/hid/controllers/npad.cpp | 12 +++--- src/core/hle/service/hid/controllers/npad.h | 8 +--- src/core/hle/service/nfp/nfp.cpp | 29 ++++++------- src/core/hle/service/nfp/nfp.h | 8 +--- src/core/hle/service/nifm/nifm.cpp | 16 +++---- src/core/hle/service/nim/nim.cpp | 14 +++--- src/core/hle/service/nvdrv/interface.cpp | 8 ++-- src/core/hle/service/nvdrv/interface.h | 2 +- src/core/hle/service/nvflinger/buffer_queue.cpp | 14 +++--- src/core/hle/service/nvflinger/buffer_queue.h | 8 +--- src/core/hle/service/nvflinger/nvflinger.cpp | 10 ++--- src/core/hle/service/nvflinger/nvflinger.h | 2 +- src/yuzu/debugger/wait_tree.cpp | 8 ++-- src/yuzu/debugger/wait_tree.h | 4 +- 32 files changed, 175 insertions(+), 317 deletions(-) diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp index 2ffdb2f5b..21fda42d6 100644 --- a/src/core/hle/kernel/hle_ipc.cpp +++ b/src/core/hle/kernel/hle_ipc.cpp @@ -53,8 +53,10 @@ SharedPtr HLERequestContext::SleepClientThread( auto& kernel = Core::System::GetInstance().Kernel(); if (!writable_event || !readable_event) { // Create event if not provided - std::tie(writable_event, readable_event) = WritableEvent::CreateEventPair( - kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason); + const auto pair = WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "HLE Pause Event: " + reason); + writable_event = pair.writable; + readable_event = pair.readable; } writable_event->Clear(); diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 9cd714586..21d7f3483 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -177,10 +177,6 @@ struct KernelCore::Impl { // allowing us to simply use a pool index or similar. Kernel::HandleTable thread_wakeup_callback_handle_table; - /// Map of named events managed by the kernel, which are retrieved when HLE services need to - /// return an event to the system. - NamedEventTable named_events; - /// Map of named ports managed by the kernel, which can be retrieved using /// the ConnectToPort SVC. NamedPortTable named_ports; @@ -227,19 +223,6 @@ const Process* KernelCore::CurrentProcess() const { return impl->current_process; } -void KernelCore::AddNamedEvent(std::string name, SharedPtr event) { - impl->named_events.emplace(std::move(name), std::move(event)); -} - -KernelCore::NamedEventTable::iterator KernelCore::FindNamedEvent(const std::string& name) { - return impl->named_events.find(name); -} - -KernelCore::NamedEventTable::const_iterator KernelCore::FindNamedEvent( - const std::string& name) const { - return impl->named_events.find(name); -} - void KernelCore::AddNamedPort(std::string name, SharedPtr port) { impl->named_ports.emplace(std::move(name), std::move(port)); } diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index f12d061eb..ea00c89f5 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -20,7 +20,6 @@ namespace Kernel { class ClientPort; class HandleTable; class Process; -class ReadableEvent; class ResourceLimit; class Thread; class Timer; @@ -28,7 +27,6 @@ class Timer; /// Represents a single instance of the kernel. class KernelCore { private: - using NamedEventTable = std::unordered_map>; using NamedPortTable = std::unordered_map>; public: @@ -68,15 +66,6 @@ public: /// Retrieves a const pointer to the current process. const Process* CurrentProcess() const; - /// Adds an event to the named event table - void AddNamedEvent(std::string name, SharedPtr event); - - /// Finds an event within the named event table wit the given name. - NamedEventTable::iterator FindNamedEvent(const std::string& name); - - /// Finds an event within the named event table wit the given name. - NamedEventTable::const_iterator FindNamedEvent(const std::string& name) const; - /// Adds a port to the named port table void AddNamedPort(std::string name, SharedPtr port); diff --git a/src/core/hle/kernel/readable_event.cpp b/src/core/hle/kernel/readable_event.cpp index 164cffbdb..92e16b4e6 100644 --- a/src/core/hle/kernel/readable_event.cpp +++ b/src/core/hle/kernel/readable_event.cpp @@ -15,34 +15,30 @@ ReadableEvent::ReadableEvent(KernelCore& kernel) : WaitObject{kernel} {} ReadableEvent::~ReadableEvent() = default; bool ReadableEvent::ShouldWait(Thread* thread) const { - return !writable_event->IsSignaled(); + return !signaled; } void ReadableEvent::Acquire(Thread* thread) { ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); - writable_event->ResetOnAcquire(); -} - -void ReadableEvent::AddWaitingThread(SharedPtr thread) { - writable_event->AddWaitingThread(thread); -} - -void ReadableEvent::RemoveWaitingThread(Thread* thread) { - writable_event->RemoveWaitingThread(thread); + if (reset_type == ResetType::OneShot) + signaled = false; } void ReadableEvent::Signal() { - writable_event->Signal(); + signaled = true; + WakeupAllWaitingThreads(); } void ReadableEvent::Clear() { - writable_event->Clear(); + signaled = false; } void ReadableEvent::WakeupAllWaitingThreads() { - writable_event->WakeupAllWaitingThreads(); - writable_event->ResetOnWakeup(); + WaitObject::WakeupAllWaitingThreads(); + + if (reset_type == ResetType::Pulse) + signaled = false; } } // namespace Kernel diff --git a/src/core/hle/kernel/readable_event.h b/src/core/hle/kernel/readable_event.h index 020ef4ebc..b1f1f4871 100644 --- a/src/core/hle/kernel/readable_event.h +++ b/src/core/hle/kernel/readable_event.h @@ -25,6 +25,10 @@ public: return name; } + ResetType GetResetType() const { + return reset_type; + } + static const HandleType HANDLE_TYPE = HandleType::Event; HandleType GetHandleType() const override { return HANDLE_TYPE; @@ -35,20 +39,15 @@ public: void WakeupAllWaitingThreads() override; - void AddWaitingThread(SharedPtr thread) override; - void RemoveWaitingThread(Thread* thread) override; - - void Signal(); void Clear(); - SharedPtr PromoteToWritable() const { - return writable_event; - } - private: explicit ReadableEvent(KernelCore& kernel); - SharedPtr writable_event; ///< WritableEvent associated with this ReadableEvent + void Signal(); + + ResetType reset_type; + bool signaled; std::string name; ///< Name of event (optional) }; diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp index 85a9c50fb..abc48ee54 100644 --- a/src/core/hle/kernel/svc.cpp +++ b/src/core/hle/kernel/svc.cpp @@ -1366,7 +1366,7 @@ static ResultCode ResetSignal(Handle handle) { ASSERT(event != nullptr); - event->PromoteToWritable()->Clear(); + event->Clear(); return RESULT_SUCCESS; } @@ -1531,7 +1531,7 @@ static ResultCode ClearEvent(Handle handle) { return ERR_INVALID_HANDLE; } - evt->PromoteToWritable()->Clear(); + evt->Clear(); return RESULT_SUCCESS; } diff --git a/src/core/hle/kernel/writable_event.cpp b/src/core/hle/kernel/writable_event.cpp index 4eb387ac0..27d7ff734 100644 --- a/src/core/hle/kernel/writable_event.cpp +++ b/src/core/hle/kernel/writable_event.cpp @@ -12,70 +12,37 @@ namespace Kernel { -WritableEvent::WritableEvent(KernelCore& kernel) : WaitObject{kernel} {} +WritableEvent::WritableEvent(KernelCore& kernel) : Object{kernel} {} WritableEvent::~WritableEvent() = default; -std::tuple, SharedPtr> WritableEvent::CreateEventPair( - KernelCore& kernel, ResetType reset_type, std::string name) { +EventPair WritableEvent::CreateEventPair(KernelCore& kernel, ResetType reset_type, + std::string name) { SharedPtr writable_event(new WritableEvent(kernel)); SharedPtr readable_event(new ReadableEvent(kernel)); writable_event->name = name + ":Writable"; - writable_event->signaled = false; - writable_event->reset_type = reset_type; + writable_event->readable = readable_event; readable_event->name = name + ":Readable"; - readable_event->writable_event = writable_event; + readable_event->signaled = false; + readable_event->reset_type = reset_type; - return std::make_tuple(std::move(writable_event), std::move(readable_event)); + return {std::move(readable_event), std::move(writable_event)}; } -SharedPtr WritableEvent::CreateRegisteredEventPair(KernelCore& kernel, - ResetType reset_type, - std::string name) { - auto [writable_event, readable_event] = CreateEventPair(kernel, reset_type, name); - kernel.AddNamedEvent(name, std::move(readable_event)); - return std::move(writable_event); -} - -bool WritableEvent::ShouldWait(Thread* thread) const { - return !signaled; -} - -void WritableEvent::Acquire(Thread* thread) { - ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); - - if (reset_type == ResetType::OneShot) - signaled = false; +ResetType WritableEvent::GetResetType() const { + return readable->reset_type; } void WritableEvent::Signal() { - signaled = true; - WakeupAllWaitingThreads(); + readable->Signal(); } void WritableEvent::Clear() { - signaled = false; -} - -void WritableEvent::ResetOnAcquire() { - if (reset_type == ResetType::OneShot) - Clear(); -} - -void WritableEvent::ResetOnWakeup() { - if (reset_type == ResetType::Pulse) - Clear(); + readable->Clear(); } bool WritableEvent::IsSignaled() const { - return signaled; -} - -void WritableEvent::WakeupAllWaitingThreads() { - WaitObject::WakeupAllWaitingThreads(); - - if (reset_type == ResetType::Pulse) - signaled = false; + return readable->signaled; } } // namespace Kernel diff --git a/src/core/hle/kernel/writable_event.h b/src/core/hle/kernel/writable_event.h index c0fe42302..4357d1b9f 100644 --- a/src/core/hle/kernel/writable_event.h +++ b/src/core/hle/kernel/writable_event.h @@ -12,8 +12,14 @@ namespace Kernel { class KernelCore; class ReadableEvent; +class WritableEvent; -class WritableEvent final : public WaitObject { +struct EventPair { + SharedPtr readable; + SharedPtr writable; +}; + +class WritableEvent final : public Object { public: ~WritableEvent() override; @@ -23,18 +29,8 @@ public: * @param reset_type ResetType describing how to create event * @param name Optional name of event */ - static std::tuple, SharedPtr> CreateEventPair( - KernelCore& kernel, ResetType reset_type, std::string name = "Unknown"); - - /** - * Creates an event and registers it in the kernel's named event table - * @param kernel The kernel instance to create this event under. - * @param reset_type ResetType describing how to create event - * @param name name of event - */ - static SharedPtr CreateRegisteredEventPair(KernelCore& kernel, - ResetType reset_type, - std::string name); + static EventPair CreateEventPair(KernelCore& kernel, ResetType reset_type, + std::string name = "Unknown"); std::string GetTypeName() const override { return "WritableEvent"; @@ -48,27 +44,17 @@ public: return HANDLE_TYPE; } - ResetType GetResetType() const { - return reset_type; - } - - bool ShouldWait(Thread* thread) const override; - void Acquire(Thread* thread) override; - - void WakeupAllWaitingThreads() override; + ResetType GetResetType() const; void Signal(); void Clear(); - void ResetOnAcquire(); - void ResetOnWakeup(); bool IsSignaled() const; private: explicit WritableEvent(KernelCore& kernel); - ResetType reset_type; ///< Current ResetType + SharedPtr readable; - bool signaled; ///< Whether the event has already been signaled std::string name; ///< Name of event (optional) }; diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp index 43c91e521..a3e0df9bf 100644 --- a/src/core/hle/service/am/am.cpp +++ b/src/core/hle/service/am/am.cpp @@ -210,8 +210,8 @@ ISelfController::ISelfController(std::shared_ptr nvflinger RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - launchable_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent"); + launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky, + "ISelfController:LaunchableEvent"); } ISelfController::~ISelfController() = default; @@ -297,11 +297,11 @@ void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) { void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_AM, "(STUBBED) called"); - launchable_event->Signal(); + launchable_event.writable->Signal(); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(launchable_event.readable); void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_AM, "(STUBBED) called"); @@ -349,9 +349,9 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c AppletMessageQueue::AppletMessageQueue() { auto& kernel = Core::System::GetInstance().Kernel(); - on_new_message = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::Sticky, "AMMessageQueue:OnMessageRecieved"); - on_operation_mode_changed = Kernel::WritableEvent::CreateRegisteredEventPair( + on_new_message = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky, + "AMMessageQueue:OnMessageRecieved"); + on_operation_mode_changed = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "AMMessageQueue:OperationModeChanged"); } @@ -359,32 +359,28 @@ AppletMessageQueue::~AppletMessageQueue() = default; const Kernel::SharedPtr& AppletMessageQueue::GetMesssageRecieveEvent() const { - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OnMessageRecieved")}; - return event->second; + return on_new_message.readable; } const Kernel::SharedPtr& AppletMessageQueue::GetOperationModeChangedEvent() const { - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OperationModeChanged")}; - return event->second; + return on_operation_mode_changed.readable; } void AppletMessageQueue::PushMessage(AppletMessage msg) { messages.push(msg); - on_new_message->Signal(); + on_new_message.writable->Signal(); } AppletMessageQueue::AppletMessage AppletMessageQueue::PopMessage() { if (messages.empty()) { - on_new_message->Clear(); + on_new_message.writable->Clear(); return AppletMessage::NoMessage; } auto msg = messages.front(); messages.pop(); if (messages.empty()) { - on_new_message->Clear(); + on_new_message.writable->Clear(); } return msg; } @@ -396,7 +392,7 @@ std::size_t AppletMessageQueue::GetMessageCount() const { void AppletMessageQueue::OperationModeChanged() { PushMessage(AppletMessage::OperationModeChanged); PushMessage(AppletMessage::PerformanceModeChanged); - on_operation_mode_changed->Signal(); + on_operation_mode_changed.writable->Signal(); } ICommonStateGetter::ICommonStateGetter(std::shared_ptr msg_queue) diff --git a/src/core/hle/service/am/am.h b/src/core/hle/service/am/am.h index ef90b0702..34c45fadf 100644 --- a/src/core/hle/service/am/am.h +++ b/src/core/hle/service/am/am.h @@ -6,13 +6,9 @@ #include #include +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/service.h" -namespace Kernel { -class ReadableEvent; -class WritableEvent; -} // namespace Kernel - namespace Service { namespace NVFlinger { class NVFlinger; @@ -62,8 +58,8 @@ public: private: std::queue messages; - Kernel::SharedPtr on_new_message; - Kernel::SharedPtr on_operation_mode_changed; + Kernel::EventPair on_new_message; + Kernel::EventPair on_operation_mode_changed; }; class IWindowController final : public ServiceFramework { @@ -123,7 +119,7 @@ private: void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx); std::shared_ptr nvflinger; - Kernel::SharedPtr launchable_event; + Kernel::EventPair launchable_event; u32 idle_time_detection_extension = 0; }; diff --git a/src/core/hle/service/am/applets/applets.cpp b/src/core/hle/service/am/applets/applets.cpp index 494205322..47da35537 100644 --- a/src/core/hle/service/am/applets/applets.cpp +++ b/src/core/hle/service/am/applets/applets.cpp @@ -15,11 +15,11 @@ namespace Service::AM::Applets { AppletDataBroker::AppletDataBroker() { auto& kernel = Core::System::GetInstance().Kernel(); - state_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair( + state_changed_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:StateChangedEvent"); - pop_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair( + pop_out_data_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopDataOutEvent"); - pop_interactive_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair( + pop_interactive_out_data_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopInteractiveDataOutEvent"); } @@ -67,7 +67,7 @@ void AppletDataBroker::PushNormalDataFromGame(IStorage storage) { void AppletDataBroker::PushNormalDataFromApplet(IStorage storage) { out_channel.push(std::make_unique(storage)); - pop_out_data_event->Signal(); + pop_out_data_event.writable->Signal(); } void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) { @@ -76,29 +76,23 @@ void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) { void AppletDataBroker::PushInteractiveDataFromApplet(IStorage storage) { out_interactive_channel.push(std::make_unique(storage)); - pop_interactive_out_data_event->Signal(); + pop_interactive_out_data_event.writable->Signal(); } void AppletDataBroker::SignalStateChanged() const { - state_changed_event->Signal(); + state_changed_event.writable->Signal(); } Kernel::SharedPtr AppletDataBroker::GetNormalDataEvent() const { - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( - "ILibraryAppletAccessor:PopDataOutEvent")}; - return event->second; + return pop_out_data_event.readable; } Kernel::SharedPtr AppletDataBroker::GetInteractiveDataEvent() const { - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( - "ILibraryAppletAccessor:PopInteractiveDataOutEvent")}; - return event->second; + return pop_interactive_out_data_event.readable; } Kernel::SharedPtr AppletDataBroker::GetStateChangedEvent() const { - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( - "ILibraryAppletAccessor:StateChangedEvent")}; - return event->second; + return state_changed_event.readable; } Applet::Applet() = default; diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h index 5cd6232cc..3eff471eb 100644 --- a/src/core/hle/service/am/applets/applets.h +++ b/src/core/hle/service/am/applets/applets.h @@ -60,13 +60,13 @@ private: // PopInteractiveDataToGame and PushInteractiveDataFromApplet std::queue> out_interactive_channel; - Kernel::SharedPtr state_changed_event; + Kernel::EventPair state_changed_event; // Signaled on PushNormalDataFromApplet - Kernel::SharedPtr pop_out_data_event; + Kernel::EventPair pop_out_data_event; // Signaled on PushInteractiveDataFromApplet - Kernel::SharedPtr pop_interactive_out_data_event; + Kernel::EventPair pop_interactive_out_data_event; }; class Applet { diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp index a89f99dc7..b276de332 100644 --- a/src/core/hle/service/aoc/aoc_u.cpp +++ b/src/core/hle/service/aoc/aoc_u.cpp @@ -63,8 +63,8 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - aoc_change_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::Sticky, "GetAddOnContentListChanged:Event"); + aoc_change_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky, + "GetAddOnContentListChanged:Event"); } AOC_U::~AOC_U() = default; @@ -144,12 +144,9 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) { void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_AOC, "(STUBBED) called"); - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("GetAddOnContentListChanged:Event")}; - IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(aoc_change_event.readable); } void InstallInterfaces(SM::ServiceManager& service_manager) { diff --git a/src/core/hle/service/aoc/aoc_u.h b/src/core/hle/service/aoc/aoc_u.h index f32a757aa..5effea730 100644 --- a/src/core/hle/service/aoc/aoc_u.h +++ b/src/core/hle/service/aoc/aoc_u.h @@ -25,7 +25,7 @@ private: void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx); std::vector add_on_content; - Kernel::SharedPtr aoc_change_event; + Kernel::EventPair aoc_change_event; }; /// Registers all AOC services with the specified service manager. diff --git a/src/core/hle/service/audio/audout_u.cpp b/src/core/hle/service/audio/audout_u.cpp index b5012e579..22e5c85ab 100644 --- a/src/core/hle/service/audio/audout_u.cpp +++ b/src/core/hle/service/audio/audout_u.cpp @@ -69,11 +69,12 @@ public: // This is the event handle used to check if the audio buffer was released auto& kernel = Core::System::GetInstance().Kernel(); - buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased"); + buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky, + "IAudioOutBufferReleased"); stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count, - std::move(unique_name), [=]() { buffer_event->Signal(); }); + std::move(unique_name), + [=]() { buffer_event.writable->Signal(); }); } private: @@ -123,9 +124,7 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleased")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(buffer_event.readable); } void AppendAudioOutBufferImpl(Kernel::HLERequestContext& ctx) { @@ -191,8 +190,8 @@ private: AudoutParams audio_params{}; - /// This is the evend handle used to check if the audio buffer was released - Kernel::SharedPtr buffer_event; + /// This is the event handle used to check if the audio buffer was released + Kernel::EventPair buffer_event; }; void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) { diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp index 9b7f7b201..945259c7d 100644 --- a/src/core/hle/service/audio/audren_u.cpp +++ b/src/core/hle/service/audio/audren_u.cpp @@ -43,14 +43,14 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - system_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent"); - renderer = std::make_unique(audren_params, system_event); + system_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky, + "IAudioRenderer:SystemEvent"); + renderer = std::make_unique(audren_params, system_event.writable); } private: void UpdateAudioCallback() { - system_event->Signal(); + system_event.writable->Signal(); } void GetSampleRate(Kernel::HLERequestContext& ctx) { @@ -114,9 +114,7 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IAudioRenderer:SystemEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(system_event.readable); } void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) { @@ -139,7 +137,7 @@ private: rb.Push(rendering_time_limit_percent); } - Kernel::SharedPtr system_event; + Kernel::EventPair system_event; std::unique_ptr renderer; u32 rendering_time_limit_percent = 100; }; @@ -166,8 +164,8 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "IAudioOutBufferReleasedEvent"); + buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "IAudioOutBufferReleasedEvent"); } private: @@ -211,13 +209,11 @@ private: void QueryAudioDeviceSystemEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_Audio, "(STUBBED) called"); - buffer_event->Signal(); + buffer_event.writable->Signal(); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleasedEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(buffer_event.readable); } void GetActiveChannelCount(Kernel::HLERequestContext& ctx) { @@ -228,7 +224,7 @@ private: rb.Push(1); } - Kernel::SharedPtr buffer_event; + Kernel::EventPair buffer_event; }; // namespace Audio diff --git a/src/core/hle/service/btdrv/btdrv.cpp b/src/core/hle/service/btdrv/btdrv.cpp index 04c78e81a..5704ca0ab 100644 --- a/src/core/hle/service/btdrv/btdrv.cpp +++ b/src/core/hle/service/btdrv/btdrv.cpp @@ -34,8 +34,8 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - register_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent"); + register_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "BT:RegisterEvent"); } private: @@ -44,10 +44,10 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("BT:RegisterEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(register_event.readable); } - Kernel::SharedPtr register_event; + + Kernel::EventPair register_event; }; class BtDrv final : public ServiceFramework { diff --git a/src/core/hle/service/btm/btm.cpp b/src/core/hle/service/btm/btm.cpp index 3ee298161..ef7398a23 100644 --- a/src/core/hle/service/btm/btm.cpp +++ b/src/core/hle/service/btm/btm.cpp @@ -57,14 +57,14 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - scan_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent"); - connection_event = Kernel::WritableEvent::CreateRegisteredEventPair( + scan_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "IBtmUserCore:ScanEvent"); + connection_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConnectionEvent"); - service_discovery = Kernel::WritableEvent::CreateRegisteredEventPair( + service_discovery = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery"); - config_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent"); + config_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "IBtmUserCore:ConfigEvent"); } private: @@ -73,46 +73,37 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ScanEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(scan_event.readable); } + void GetConnectionEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConnectionEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(connection_event.readable); } + void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:Discovery")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(service_discovery.readable); } + void GetConfigEvent(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_BTM, "(STUBBED) called"); IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConfigEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(config_event.readable); } - Kernel::SharedPtr scan_event; - Kernel::SharedPtr connection_event; - Kernel::SharedPtr service_discovery; - Kernel::SharedPtr config_event; + Kernel::EventPair scan_event; + Kernel::EventPair connection_event; + Kernel::EventPair service_discovery; + Kernel::EventPair config_event; }; class BTM_USR final : public ServiceFramework { diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp index df39a6dc4..342c2eb81 100644 --- a/src/core/hle/service/hid/controllers/npad.cpp +++ b/src/core/hle/service/hid/controllers/npad.cpp @@ -169,7 +169,7 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) { void Controller_NPad::OnInit() { auto& kernel = Core::System::GetInstance().Kernel(); - styleset_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair( + styleset_changed_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged"); if (!IsControllerActivated()) { @@ -496,7 +496,7 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) { had_controller_update = true; } if (had_controller_update) { - styleset_changed_event->Signal(); + styleset_changed_event.writable->Signal(); } } } @@ -511,7 +511,7 @@ std::size_t Controller_NPad::GetSupportedNPadIdTypesSize() const { } void Controller_NPad::SetHoldType(NpadHoldType joy_hold_type) { - styleset_changed_event->Signal(); + styleset_changed_event.writable->Signal(); hold_type = joy_hold_type; } @@ -543,10 +543,8 @@ void Controller_NPad::VibrateController(const std::vector& controller_ids, Kernel::SharedPtr Controller_NPad::GetStyleSetChangedEvent() const { // TODO(ogniK): Figure out the best time to signal this event. This event seems that it should // be signalled at least once, and signaled after a new controller is connected? - styleset_changed_event->Signal(); - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("npad:NpadStyleSetChanged")}; - return event->second; + styleset_changed_event.writable->Signal(); + return styleset_changed_event.readable; } Controller_NPad::Vibration Controller_NPad::GetLastVibration() const { diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h index c960d0f57..29851f16a 100644 --- a/src/core/hle/service/hid/controllers/npad.h +++ b/src/core/hle/service/hid/controllers/npad.h @@ -9,14 +9,10 @@ #include "common/common_types.h" #include "core/frontend/input.h" #include "core/hle/kernel/object.h" +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/hid/controllers/controller_base.h" #include "core/settings.h" -namespace Kernel { -class ReadableEvent; -class WritableEvent; -} // namespace Kernel - namespace Service::HID { constexpr u32 NPAD_HANDHELD = 32; @@ -308,7 +304,7 @@ private: sticks; std::vector supported_npad_id_types{}; NpadHoldType hold_type{NpadHoldType::Vertical}; - Kernel::SharedPtr styleset_changed_event; + Kernel::EventPair styleset_changed_event; Vibration last_processed_vibration{}; std::array connected_controllers{}; bool can_controllers_vibrate{true}; diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp index 75c605364..d5df112a0 100644 --- a/src/core/hle/service/nfp/nfp.cpp +++ b/src/core/hle/service/nfp/nfp.cpp @@ -25,8 +25,8 @@ constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP, Module::Interface::Interface(std::shared_ptr module, const char* name) : ServiceFramework(name), module(std::move(module)) { auto& kernel = Core::System::GetInstance().Kernel(); - nfc_tag_load = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected"); + nfc_tag_load = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "IUser:NFCTagDetected"); } Module::Interface::~Interface() = default; @@ -65,9 +65,9 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - deactivate_event = Kernel::WritableEvent::CreateRegisteredEventPair( + deactivate_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent"); - availability_change_event = Kernel::WritableEvent::CreateRegisteredEventPair( + availability_change_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "IUser:AvailabilityChangeEvent"); } @@ -166,10 +166,7 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IUser:DeactivateEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(deactivate_event.readable); } void StopDetection(Kernel::HLERequestContext& ctx) { @@ -178,7 +175,7 @@ private: switch (device_state) { case DeviceState::TagFound: case DeviceState::TagNearby: - deactivate_event->Signal(); + deactivate_event.writable->Signal(); device_state = DeviceState::Initialized; break; case DeviceState::SearchingForTag: @@ -269,9 +266,7 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("IUser:AvailabilityChangeEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(availability_change_event.readable); } void GetRegisterInfo(Kernel::HLERequestContext& ctx) { @@ -326,8 +321,8 @@ private: const u32 npad_id{0}; // Player 1 controller State state{State::NonInitialized}; DeviceState device_state{DeviceState::Initialized}; - Kernel::SharedPtr deactivate_event; - Kernel::SharedPtr availability_change_event; + Kernel::EventPair deactivate_event; + Kernel::EventPair availability_change_event; const Module::Interface& nfp_interface; }; @@ -346,14 +341,14 @@ bool Module::Interface::LoadAmiibo(const std::vector& buffer) { } std::memcpy(&amiibo, buffer.data(), sizeof(amiibo)); - nfc_tag_load->Signal(); + nfc_tag_load.writable->Signal(); return true; } const Kernel::SharedPtr& Module::Interface::GetNFCEvent() const { - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("IUser:NFCTagDetected")}; - return event->second; + return nfc_tag_load.readable; } + const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const { return amiibo; } diff --git a/src/core/hle/service/nfp/nfp.h b/src/core/hle/service/nfp/nfp.h index 0ab1ca997..437c10aad 100644 --- a/src/core/hle/service/nfp/nfp.h +++ b/src/core/hle/service/nfp/nfp.h @@ -6,13 +6,9 @@ #include #include +#include "core/hle/kernel/writable_event.h" #include "core/hle/service/service.h" -namespace Kernel { -class ReadableEvent; -class WritableEvent; -} // namespace Kernel - namespace Service::NFP { class Module final { @@ -41,7 +37,7 @@ public: const AmiiboFile& GetAmiiboBuffer() const; private: - Kernel::SharedPtr nfc_tag_load{}; + Kernel::EventPair nfc_tag_load{}; AmiiboFile amiibo{}; protected: diff --git a/src/core/hle/service/nifm/nifm.cpp b/src/core/hle/service/nifm/nifm.cpp index 80a66bce3..60479bb45 100644 --- a/src/core/hle/service/nifm/nifm.cpp +++ b/src/core/hle/service/nifm/nifm.cpp @@ -58,10 +58,10 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - event1 = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "IRequest:Event1"); - event2 = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "IRequest:Event2"); + event1 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "IRequest:Event1"); + event2 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "IRequest:Event2"); } private: @@ -92,11 +92,7 @@ private: IPC::ResponseBuilder rb{ctx, 2, 2}; rb.Push(RESULT_SUCCESS); - - const auto& event1{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event1")}; - const auto& event2{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event2")}; - - rb.PushCopyObjects(event1->second, event2->second); + rb.PushCopyObjects(event1.readable, event2.readable); } void Cancel(Kernel::HLERequestContext& ctx) { @@ -113,7 +109,7 @@ private: rb.Push(RESULT_SUCCESS); } - Kernel::SharedPtr event1, event2; + Kernel::EventPair event1, event2; }; class INetworkProfile final : public ServiceFramework { diff --git a/src/core/hle/service/nim/nim.cpp b/src/core/hle/service/nim/nim.cpp index d181a781c..0dabcd23b 100644 --- a/src/core/hle/service/nim/nim.cpp +++ b/src/core/hle/service/nim/nim.cpp @@ -140,19 +140,18 @@ public: RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - finished_event = Kernel::WritableEvent::CreateRegisteredEventPair( + finished_event = Kernel::WritableEvent::CreateEventPair( kernel, Kernel::ResetType::OneShot, "IEnsureNetworkClockAvailabilityService:FinishEvent"); } private: - Kernel::SharedPtr finished_event; + Kernel::EventPair finished_event; void StartTask(Kernel::HLERequestContext& ctx) { // No need to connect to the internet, just finish the task straight away. LOG_DEBUG(Service_NIM, "called"); - - finished_event->Signal(); + finished_event.writable->Signal(); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(RESULT_SUCCESS); } @@ -162,9 +161,7 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( - "IEnsureNetworkClockAvailabilityService:FinishEvent")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(finished_event.readable); } void GetResult(Kernel::HLERequestContext& ctx) { @@ -176,8 +173,7 @@ private: void Cancel(Kernel::HLERequestContext& ctx) { LOG_DEBUG(Service_NIM, "called"); - - finished_event->Clear(); + finished_event.writable->Clear(); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(RESULT_SUCCESS); } diff --git a/src/core/hle/service/nvdrv/interface.cpp b/src/core/hle/service/nvdrv/interface.cpp index 3d89b4020..3b9ab4b14 100644 --- a/src/core/hle/service/nvdrv/interface.cpp +++ b/src/core/hle/service/nvdrv/interface.cpp @@ -71,9 +71,7 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 3, 1}; rb.Push(RESULT_SUCCESS); - - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("NVDRV::query_event")}; - rb.PushCopyObjects(event->second); + rb.PushCopyObjects(query_event.readable); rb.Push(0); } @@ -131,8 +129,8 @@ NVDRV::NVDRV(std::shared_ptr nvdrv, const char* name) RegisterHandlers(functions); auto& kernel = Core::System::GetInstance().Kernel(); - query_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::OneShot, "NVDRV::query_event"); + query_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, + "NVDRV::query_event"); } NVDRV::~NVDRV() = default; diff --git a/src/core/hle/service/nvdrv/interface.h b/src/core/hle/service/nvdrv/interface.h index a27252038..fe311b069 100644 --- a/src/core/hle/service/nvdrv/interface.h +++ b/src/core/hle/service/nvdrv/interface.h @@ -34,7 +34,7 @@ private: u64 pid{}; - Kernel::SharedPtr query_event; + Kernel::EventPair query_event; }; } // namespace Service::Nvidia diff --git a/src/core/hle/service/nvflinger/buffer_queue.cpp b/src/core/hle/service/nvflinger/buffer_queue.cpp index 7b07750b5..fc07d9bb8 100644 --- a/src/core/hle/service/nvflinger/buffer_queue.cpp +++ b/src/core/hle/service/nvflinger/buffer_queue.cpp @@ -16,8 +16,8 @@ namespace Service::NVFlinger { BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) { auto& kernel = Core::System::GetInstance().Kernel(); - buffer_wait_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::Sticky, "BufferQueue NativeHandle"); + buffer_wait_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky, + "BufferQueue NativeHandle"); } BufferQueue::~BufferQueue() = default; @@ -31,7 +31,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer) buffer.status = Buffer::Status::Free; queue.emplace_back(buffer); - buffer_wait_event->Signal(); + buffer_wait_event.writable->Signal(); } std::optional BufferQueue::DequeueBuffer(u32 width, u32 height) { @@ -90,7 +90,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) { ASSERT(itr->status == Buffer::Status::Acquired); itr->status = Buffer::Status::Free; - buffer_wait_event->Signal(); + buffer_wait_event.writable->Signal(); } u32 BufferQueue::Query(QueryType type) { @@ -108,13 +108,11 @@ u32 BufferQueue::Query(QueryType type) { } Kernel::SharedPtr BufferQueue::GetWritableBufferWaitEvent() const { - return buffer_wait_event; + return buffer_wait_event.writable; } Kernel::SharedPtr BufferQueue::GetBufferWaitEvent() const { - const auto& event{ - Core::System::GetInstance().Kernel().FindNamedEvent("BufferQueue NativeHandle")}; - return event->second; + return buffer_wait_event.readable; } } // namespace Service::NVFlinger diff --git a/src/core/hle/service/nvflinger/buffer_queue.h b/src/core/hle/service/nvflinger/buffer_queue.h index 8b2a2b7de..b171f256c 100644 --- a/src/core/hle/service/nvflinger/buffer_queue.h +++ b/src/core/hle/service/nvflinger/buffer_queue.h @@ -11,16 +11,12 @@ #include "common/math_util.h" #include "common/swap.h" #include "core/hle/kernel/object.h" +#include "core/hle/kernel/writable_event.h" namespace CoreTiming { struct EventType; } -namespace Kernel { -class ReadableEvent; -class WritableEvent; -} // namespace Kernel - namespace Service::NVFlinger { struct IGBPBuffer { @@ -100,7 +96,7 @@ private: u64 layer_id; std::vector queue; - Kernel::SharedPtr buffer_wait_event; + Kernel::EventPair buffer_wait_event; }; } // namespace Service::NVFlinger diff --git a/src/core/hle/service/nvflinger/nvflinger.cpp b/src/core/hle/service/nvflinger/nvflinger.cpp index 2a329cb8e..05af2d593 100644 --- a/src/core/hle/service/nvflinger/nvflinger.cpp +++ b/src/core/hle/service/nvflinger/nvflinger.cpp @@ -87,9 +87,7 @@ u32 NVFlinger::GetBufferQueueId(u64 display_id, u64 layer_id) { } Kernel::SharedPtr NVFlinger::GetVsyncEvent(u64 display_id) { - const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent( - fmt::format("Display VSync Event {}", display_id))}; - return event->second; + return GetDisplay(display_id).vsync_event.readable; } std::shared_ptr NVFlinger::GetBufferQueue(u32 id) const { @@ -121,7 +119,7 @@ Layer& NVFlinger::GetLayer(u64 display_id, u64 layer_id) { void NVFlinger::Compose() { for (auto& display : displays) { // Trigger vsync for this display at the end of drawing - SCOPE_EXIT({ display.vsync_event->Signal(); }); + SCOPE_EXIT({ display.vsync_event.writable->Signal(); }); // Don't do anything for displays without layers. if (display.layers.empty()) @@ -168,8 +166,8 @@ Layer::~Layer() = default; Display::Display(u64 id, std::string name) : id(id), name(std::move(name)) { auto& kernel = Core::System::GetInstance().Kernel(); - vsync_event = Kernel::WritableEvent::CreateRegisteredEventPair( - kernel, Kernel::ResetType::Pulse, fmt::format("Display VSync Event {}", id)); + vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Pulse, + fmt::format("Display VSync Event {}", id)); } Display::~Display() = default; diff --git a/src/core/hle/service/nvflinger/nvflinger.h b/src/core/hle/service/nvflinger/nvflinger.h index 1a9e74f35..9abba555b 100644 --- a/src/core/hle/service/nvflinger/nvflinger.h +++ b/src/core/hle/service/nvflinger/nvflinger.h @@ -45,7 +45,7 @@ struct Display { std::string name; std::vector layers; - Kernel::SharedPtr vsync_event; + Kernel::EventPair vsync_event; }; class NVFlinger final { diff --git a/src/yuzu/debugger/wait_tree.cpp b/src/yuzu/debugger/wait_tree.cpp index 797be6c4a..96c57fe97 100644 --- a/src/yuzu/debugger/wait_tree.cpp +++ b/src/yuzu/debugger/wait_tree.cpp @@ -10,11 +10,11 @@ #include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/mutex.h" #include "core/hle/kernel/process.h" +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/scheduler.h" #include "core/hle/kernel/thread.h" #include "core/hle/kernel/timer.h" #include "core/hle/kernel/wait_object.h" -#include "core/hle/kernel/writable_event.h" #include "core/memory.h" WaitTreeItem::WaitTreeItem() = default; @@ -154,7 +154,7 @@ QString WaitTreeWaitObject::GetText() const { std::unique_ptr WaitTreeWaitObject::make(const Kernel::WaitObject& object) { switch (object.GetHandleType()) { case Kernel::HandleType::Event: - return std::make_unique(static_cast(object)); + return std::make_unique(static_cast(object)); case Kernel::HandleType::Timer: return std::make_unique(static_cast(object)); case Kernel::HandleType::Thread: @@ -332,7 +332,7 @@ std::vector> WaitTreeThread::GetChildren() const { return list; } -WaitTreeEvent::WaitTreeEvent(const Kernel::WritableEvent& object) : WaitTreeWaitObject(object) {} +WaitTreeEvent::WaitTreeEvent(const Kernel::ReadableEvent& object) : WaitTreeWaitObject(object) {} WaitTreeEvent::~WaitTreeEvent() = default; std::vector> WaitTreeEvent::GetChildren() const { @@ -341,7 +341,7 @@ std::vector> WaitTreeEvent::GetChildren() const { list.push_back(std::make_unique( tr("reset type = %1") .arg(GetResetTypeQString( - static_cast(object).GetResetType())))); + static_cast(object).GetResetType())))); return list; } diff --git a/src/yuzu/debugger/wait_tree.h b/src/yuzu/debugger/wait_tree.h index c0b6e0e7f..492fb6ac9 100644 --- a/src/yuzu/debugger/wait_tree.h +++ b/src/yuzu/debugger/wait_tree.h @@ -17,8 +17,8 @@ class EmuThread; namespace Kernel { +class ReadableEvent; class WaitObject; -class WritableEvent; class Thread; class Timer; } // namespace Kernel @@ -144,7 +144,7 @@ public: class WaitTreeEvent : public WaitTreeWaitObject { Q_OBJECT public: - explicit WaitTreeEvent(const Kernel::WritableEvent& object); + explicit WaitTreeEvent(const Kernel::ReadableEvent& object); ~WaitTreeEvent() override; std::vector> GetChildren() const override; -- cgit v1.2.3 From 170d7078507745fee4c8952aa5888108b2b76b91 Mon Sep 17 00:00:00 2001 From: Zach Hilman Date: Thu, 29 Nov 2018 09:14:12 -0500 Subject: hle_ipc: Refactor SleepClientThread to avoid ReadableEvent --- src/core/hle/kernel/hle_ipc.cpp | 6 +++--- src/core/hle/kernel/hle_ipc.h | 4 +--- src/core/hle/kernel/kernel.cpp | 2 -- src/core/hle/kernel/writable_event.cpp | 4 ++++ src/core/hle/kernel/writable_event.h | 2 ++ src/core/hle/service/am/am.cpp | 1 + src/core/hle/service/am/applets/applets.h | 6 +----- src/core/hle/service/nfp/nfp.h | 1 + src/core/hle/service/vi/vi.cpp | 2 +- 9 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp index 21fda42d6..61ce7d7e4 100644 --- a/src/core/hle/kernel/hle_ipc.cpp +++ b/src/core/hle/kernel/hle_ipc.cpp @@ -39,7 +39,7 @@ void SessionRequestHandler::ClientDisconnected(const SharedPtr& s SharedPtr HLERequestContext::SleepClientThread( SharedPtr thread, const std::string& reason, u64 timeout, WakeupCallback&& callback, - SharedPtr writable_event, SharedPtr readable_event) { + SharedPtr writable_event) { // Put the client thread to sleep until the wait event is signaled or the timeout expires. thread->SetWakeupCallback([context = *this, callback]( ThreadWakeupReason reason, SharedPtr thread, @@ -51,14 +51,14 @@ SharedPtr HLERequestContext::SleepClientThread( }); auto& kernel = Core::System::GetInstance().Kernel(); - if (!writable_event || !readable_event) { + if (!writable_event) { // Create event if not provided const auto pair = WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason); writable_event = pair.writable; - readable_event = pair.readable; } + const auto readable_event{writable_event->GetReadableEvent()}; writable_event->Clear(); thread->SetStatus(ThreadStatus::WaitHLEEvent); thread->SetWaitObjects({readable_event}); diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h index 557940f11..e5c0610cd 100644 --- a/src/core/hle/kernel/hle_ipc.h +++ b/src/core/hle/kernel/hle_ipc.h @@ -122,13 +122,11 @@ public: * was called. * @param writable_event Event to use to wake up the thread. If unspecified, an event will be * created. - * @param readable_event Event to be bound to the thread to wake up upon. * @returns Event that when signaled will resume the thread and call the callback function. */ SharedPtr SleepClientThread(SharedPtr thread, const std::string& reason, u64 timeout, WakeupCallback&& callback, - SharedPtr writable_event = nullptr, - SharedPtr readable_event = nullptr); + SharedPtr writable_event = nullptr); /// Populates this context with data from the requesting process/thread. ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table, diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 21d7f3483..e441c5bc6 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -17,11 +17,9 @@ #include "core/hle/kernel/handle_table.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/process.h" -#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/resource_limit.h" #include "core/hle/kernel/thread.h" #include "core/hle/kernel/timer.h" -#include "core/hle/kernel/writable_event.h" #include "core/hle/lock.h" #include "core/hle/result.h" diff --git a/src/core/hle/kernel/writable_event.cpp b/src/core/hle/kernel/writable_event.cpp index 27d7ff734..a58ea6ec8 100644 --- a/src/core/hle/kernel/writable_event.cpp +++ b/src/core/hle/kernel/writable_event.cpp @@ -29,6 +29,10 @@ EventPair WritableEvent::CreateEventPair(KernelCore& kernel, ResetType reset_typ return {std::move(readable_event), std::move(writable_event)}; } +SharedPtr WritableEvent::GetReadableEvent() const { + return readable; +} + ResetType WritableEvent::GetResetType() const { return readable->reset_type; } diff --git a/src/core/hle/kernel/writable_event.h b/src/core/hle/kernel/writable_event.h index 4357d1b9f..fc57d18d7 100644 --- a/src/core/hle/kernel/writable_event.h +++ b/src/core/hle/kernel/writable_event.h @@ -44,6 +44,8 @@ public: return HANDLE_TYPE; } + SharedPtr GetReadableEvent() const; + ResetType GetResetType() const; void Signal(); diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp index a3e0df9bf..3a7b6da84 100644 --- a/src/core/hle/service/am/am.cpp +++ b/src/core/hle/service/am/am.cpp @@ -302,6 +302,7 @@ void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(RESULT_SUCCESS); rb.PushCopyObjects(launchable_event.readable); +} void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) { LOG_WARNING(Service_AM, "(STUBBED) called"); diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h index 3eff471eb..b0a8913c3 100644 --- a/src/core/hle/service/am/applets/applets.h +++ b/src/core/hle/service/am/applets/applets.h @@ -8,14 +8,10 @@ #include #include "common/swap.h" #include "core/hle/kernel/kernel.h" +#include "core/hle/kernel/writable_event.h" union ResultCode; -namespace Kernel { -class ReadableEvent; -class WritableEvent; -} // namespace Kernel - namespace Service::AM { class IStorage; diff --git a/src/core/hle/service/nfp/nfp.h b/src/core/hle/service/nfp/nfp.h index 437c10aad..a1817e991 100644 --- a/src/core/hle/service/nfp/nfp.h +++ b/src/core/hle/service/nfp/nfp.h @@ -6,6 +6,7 @@ #include #include +#include "core/hle/kernel/readable_event.h" #include "core/hle/kernel/writable_event.h" #include "core/hle/service/service.h" diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp index 47beaf8f6..717eae36a 100644 --- a/src/core/hle/service/vi/vi.cpp +++ b/src/core/hle/service/vi/vi.cpp @@ -548,7 +548,7 @@ private: IPC::ResponseBuilder rb{ctx, 2}; rb.Push(RESULT_SUCCESS); }, - buffer_queue->GetWritableBufferWaitEvent(), buffer_queue->GetBufferWaitEvent()); + buffer_queue->GetWritableBufferWaitEvent()); } } else if (transaction == TransactionId::RequestBuffer) { IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()}; -- cgit v1.2.3