kernel/event: Reference ReadableEvent from WritableEvent

2025-10-31 07:59:02 -05:00 · 2018-11-27 09:18:29 -05:00
parent ff610103b5
commit a342bcc9b1
32 changed files with 175 additions and 317 deletions
--- 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::NVFlinger> 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<Kernel::ReadableEvent>& AppletMessageQueue::GetMesssageRecieveEvent()
    const {
-    const auto& event{
-        Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OnMessageRecieved")};
-    return event->second;
+    return on_new_message.readable;
 }

 const Kernel::SharedPtr<Kernel::ReadableEvent>& 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<AppletMessageQueue> msg_queue)
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@@ -6,13 +6,9 @@

 #include <memory>
 #include <queue>
+#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<AppletMessage> messages;
-    Kernel::SharedPtr<Kernel::WritableEvent> on_new_message;
-    Kernel::SharedPtr<Kernel::WritableEvent> on_operation_mode_changed;
+    Kernel::EventPair on_new_message;
+    Kernel::EventPair on_operation_mode_changed;
 };

 class IWindowController final : public ServiceFramework<IWindowController> {
@@ -123,7 +119,7 @@ private:
    void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);

    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
-    Kernel::SharedPtr<Kernel::WritableEvent> launchable_event;
+    Kernel::EventPair launchable_event;
    u32 idle_time_detection_extension = 0;
 };

--- 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<IStorage>(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<IStorage>(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<Kernel::ReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
-        "ILibraryAppletAccessor:PopDataOutEvent")};
-    return event->second;
+    return pop_out_data_event.readable;
 }

 Kernel::SharedPtr<Kernel::ReadableEvent> 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<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
-    const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
-        "ILibraryAppletAccessor:StateChangedEvent")};
-    return event->second;
+    return state_changed_event.readable;
 }

 Applet::Applet() = default;
--- 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<std::unique_ptr<IStorage>> out_interactive_channel;

-    Kernel::SharedPtr<Kernel::WritableEvent> state_changed_event;
+    Kernel::EventPair state_changed_event;

    // Signaled on PushNormalDataFromApplet
-    Kernel::SharedPtr<Kernel::WritableEvent> pop_out_data_event;
+    Kernel::EventPair pop_out_data_event;

    // Signaled on PushInteractiveDataFromApplet
-    Kernel::SharedPtr<Kernel::WritableEvent> pop_interactive_out_data_event;
+    Kernel::EventPair pop_interactive_out_data_event;
 };

 class Applet {
--- 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) {
--- 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<u64> add_on_content;
-    Kernel::SharedPtr<Kernel::WritableEvent> aoc_change_event;
+    Kernel::EventPair aoc_change_event;
 };

 /// Registers all AOC services with the specified service manager.
--- 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<Kernel::WritableEvent> 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) {
--- 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<AudioCore::AudioRenderer>(audren_params, system_event);
+        system_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
+                                                              "IAudioRenderer:SystemEvent");
+        renderer = std::make_unique<AudioCore::AudioRenderer>(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<Kernel::WritableEvent> system_event;
+    Kernel::EventPair system_event;
    std::unique_ptr<AudioCore::AudioRenderer> 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<u32>(1);
    }

-    Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
+    Kernel::EventPair buffer_event;

 }; // namespace Audio

--- 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<Kernel::WritableEvent> register_event;
+
+    Kernel::EventPair register_event;
 };

 class BtDrv final : public ServiceFramework<BtDrv> {
--- 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<Kernel::WritableEvent> scan_event;
-    Kernel::SharedPtr<Kernel::WritableEvent> connection_event;
-    Kernel::SharedPtr<Kernel::WritableEvent> service_discovery;
-    Kernel::SharedPtr<Kernel::WritableEvent> config_event;
+    Kernel::EventPair scan_event;
+    Kernel::EventPair connection_event;
+    Kernel::EventPair service_discovery;
+    Kernel::EventPair config_event;
 };

 class BTM_USR final : public ServiceFramework<BTM_USR> {
--- 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<u32>& controller_ids,
 Kernel::SharedPtr<Kernel::ReadableEvent> 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 {
--- 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<u32> supported_npad_id_types{};
    NpadHoldType hold_type{NpadHoldType::Vertical};
-    Kernel::SharedPtr<Kernel::WritableEvent> styleset_changed_event;
+    Kernel::EventPair styleset_changed_event;
    Vibration last_processed_vibration{};
    std::array<ControllerHolder, 10> connected_controllers{};
    bool can_controllers_vibrate{true};
--- 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> 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<Kernel::WritableEvent> deactivate_event;
-    Kernel::SharedPtr<Kernel::WritableEvent> 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<u8>& buffer) {
    }

    std::memcpy(&amiibo, buffer.data(), sizeof(amiibo));
-    nfc_tag_load->Signal();
+    nfc_tag_load.writable->Signal();
    return true;
 }

 const Kernel::SharedPtr<Kernel::ReadableEvent>& 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;
 }
--- a/src/core/hle/service/nfp/nfp.h
+++ b/src/core/hle/service/nfp/nfp.h
@@ -6,13 +6,9 @@

 #include <array>
 #include <vector>
+#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<Kernel::WritableEvent> nfc_tag_load{};
+        Kernel::EventPair nfc_tag_load{};
        AmiiboFile amiibo{};

    protected:
--- 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<Kernel::WritableEvent> event1, event2;
+    Kernel::EventPair event1, event2;
 };

 class INetworkProfile final : public ServiceFramework<INetworkProfile> {
--- 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<Kernel::WritableEvent> 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);
    }
--- 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<u32>(0);
 }

@@ -131,8 +129,8 @@ NVDRV::NVDRV(std::shared_ptr<Module> 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;
--- 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<Kernel::WritableEvent> query_event;
+    Kernel::EventPair query_event;
 };

 } // namespace Service::Nvidia
--- 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<u32> 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<Kernel::WritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {
-    return buffer_wait_event;
+    return buffer_wait_event.writable;
 }

 Kernel::SharedPtr<Kernel::ReadableEvent> BufferQueue::GetBufferWaitEvent() const {
-    const auto& event{
-        Core::System::GetInstance().Kernel().FindNamedEvent("BufferQueue NativeHandle")};
-    return event->second;
+    return buffer_wait_event.readable;
 }

 } // namespace Service::NVFlinger
--- 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<Buffer> queue;
-    Kernel::SharedPtr<Kernel::WritableEvent> buffer_wait_event;
+    Kernel::EventPair buffer_wait_event;
 };

 } // namespace Service::NVFlinger
--- 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<Kernel::ReadableEvent> 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<BufferQueue> 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;
--- 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<Layer> layers;
-    Kernel::SharedPtr<Kernel::WritableEvent> vsync_event;
+    Kernel::EventPair vsync_event;
 };

 class NVFlinger final {