1 files changed, 18 insertions, 19 deletions

diff --git a/src/core/hle/kernel/svc/svc_event.cpp b/src/core/hle/kernel/svc/svc_event.cpp
index 586cb2b14e..36de3b9096 100644
--- a/src/core/hle/kernel/svc/svc_event.cpp
+++ b/src/core/hle/kernel/svc/svc_event.cpp
@@ -22,9 +22,9 @@ Result SignalEvent(Core::System& system, Handle event_handle) {
     // Fail-safe for system applets
     const auto program_id = GetCurrentProcess(system.Kernel()).GetProgramId();
     if ((program_id & 0xFFFFFFFFFFFFFF00ull) == 0x0100000000001000ull) {
-        KScopedAutoObject event = handle_table.GetObject<KEvent>(event_handle);
+        KScopedAutoObject event = handle_table.GetObject<KEvent>(system.Kernel(), event_handle);
         if (event.IsNotNull()) {
-            event->Signal();
+            event->Signal(system.Kernel());
         } else {
             LOG_WARNING(Kernel_SVC, "SignalEvent best-effort unknown handle=0x{:08X} (ignored)",
                         event_handle);
@@ -34,10 +34,10 @@ Result SignalEvent(Core::System& system, Handle event_handle) {
 
 
     // Get the event.
-    KScopedAutoObject event = handle_table.GetObject<KEvent>(event_handle);
+    KScopedAutoObject event = handle_table.GetObject<KEvent>(system.Kernel(), event_handle);
     R_UNLESS(event.IsNotNull(), ResultInvalidHandle);
 
-    R_RETURN(event->Signal());
+    R_RETURN(event->Signal(system.Kernel()));
 }
 
 Result ClearEvent(Core::System& system, Handle event_handle) {
@@ -48,18 +48,18 @@ Result ClearEvent(Core::System& system, Handle event_handle) {
 
     // Try to clear the writable event.
     {
-        KScopedAutoObject event = handle_table.GetObject<KEvent>(event_handle);
+        KScopedAutoObject event = handle_table.GetObject<KEvent>(system.Kernel(), event_handle);
         if (event.IsNotNull()) {
-            event->Clear();
+            event->Clear(system.Kernel());
             R_SUCCEED();
         }
     }
 
     // Try to clear the readable event.
     {
-        KScopedAutoObject readable_event = handle_table.GetObject<KReadableEvent>(event_handle);
+        KScopedAutoObject readable_event = handle_table.GetObject<KReadableEvent>(system.Kernel(), event_handle);
         if (readable_event.IsNotNull()) {
-            readable_event->Clear();
+            readable_event->Clear(system.Kernel());
             R_SUCCEED();
         }
     }
@@ -71,43 +71,42 @@ Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {
     LOG_DEBUG(Kernel_SVC, "called");
 
     // Get the kernel reference and handle table.
-    auto& kernel = system.Kernel();
-    auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
+    auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
 
     // Reserve a new event from the process resource limit
-    KScopedResourceReservation event_reservation(GetCurrentProcessPointer(kernel),
+    KScopedResourceReservation event_reservation(system.Kernel(), GetCurrentProcessPointer(system.Kernel()),
                                                  LimitableResource::EventCountMax);
     R_UNLESS(event_reservation.Succeeded(), ResultLimitReached);
 
     // Create a new event.
-    KEvent* event = KEvent::Create(kernel);
+    KEvent* event = KEvent::Create(system.Kernel());
     R_UNLESS(event != nullptr, ResultOutOfResource);
 
     // Initialize the event.
-    event->Initialize(GetCurrentProcessPointer(kernel));
+    event->Initialize(system.Kernel(), GetCurrentProcessPointer(system.Kernel()));
 
     // Commit the thread reservation.
     event_reservation.Commit();
 
     // Ensure that we clean up the event (and its only references are handle table) on function end.
     SCOPE_EXIT {
-        event->GetReadableEvent().Close();
-        event->Close();
+        event->GetReadableEvent().Close(system.Kernel());
+        event->Close(system.Kernel());
     };
 
     // Register the event.
-    KEvent::Register(kernel, event);
+    KEvent::Register(system.Kernel(), event);
 
     // Add the event to the handle table.
-    R_TRY(handle_table.Add(out_write, event));
+    R_TRY(handle_table.Add(system.Kernel(), out_write, event));
 
     // Ensure that we maintain a clean handle state on exit.
     ON_RESULT_FAILURE {
-        handle_table.Remove(*out_write);
+        handle_table.Remove(system.Kernel(), *out_write);
     };
 
     // Add the readable event to the handle table.
-    R_RETURN(handle_table.Add(out_read, std::addressof(event->GetReadableEvent())));
+    R_RETURN(handle_table.Add(system.Kernel(), out_read, std::addressof(event->GetReadableEvent())));
 }
 
 Result SignalEvent64(Core::System& system, Handle event_handle) {