From a56fc84e7a116681373ab9157193d2b8ae0f29af Mon Sep 17 00:00:00 2001
From: Zach Hilman <zachhilman@gmail.com>
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(-)

(limited to 'src')

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<ServerSession>& s
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
-SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
-                                                      const std::string& reason, u64 timeout,
-                                                      WakeupCallback&& callback,
-                                                      Kernel::SharedPtr<Kernel::Event> event) {
-
+SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
+    SharedPtr<Thread> thread, const std::string& reason, u64 timeout, WakeupCallback&& callback,
+    SharedPtr<WritableEvent> writable_event, SharedPtr<ReadableEvent> 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> thread,
@@ -51,23 +50,23 @@ SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> 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<Kernel::ServerSession> 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<Event> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
-                                       u64 timeout, WakeupCallback&& callback,
-                                       Kernel::SharedPtr<Kernel::Event> event = nullptr);
+    SharedPtr<WritableEvent> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
+                                               u64 timeout, WakeupCallback&& callback,
+                                               SharedPtr<WritableEvent> writable_event = nullptr,
+                                               SharedPtr<ReadableEvent> readable_event = nullptr);
 
     /// Populates this context with data from the requesting process/thread.
     ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
-- 
cgit v1.2.3