1 files changed, 20 insertions, 15 deletions

diff --git a/src/core/hle/kernel/k_event.cpp b/src/core/hle/kernel/k_event.cpp
index d92b491f8b..216d4ae575 100644
--- a/src/core/hle/kernel/k_event.cpp
+++ b/src/core/hle/kernel/k_event.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,56 +11,58 @@
 namespace Kernel {
 
 KEvent::KEvent(KernelCore& kernel)
-    : KAutoObjectWithSlabHeapAndContainer{kernel}, m_readable_event{kernel} {}
+    : KAutoObjectWithSlabHeapAndContainer{kernel}
+    , m_readable_event{kernel}
+{}
 
 KEvent::~KEvent() = default;
 
-void KEvent::Initialize(KProcess* owner) {
+void KEvent::Initialize(KernelCore& kernel, KProcess* owner) {
     // Create our readable event.
     KAutoObject::Create(std::addressof(m_readable_event));
 
     // Initialize our readable event.
-    m_readable_event.Initialize(this);
+    m_readable_event.Initialize(kernel, this);
 
     // Set our owner process.
     // HACK: this should never be nullptr, but service threads don't have a
     // proper parent process yet.
     if (owner != nullptr) {
         m_owner = owner;
-        m_owner->Open();
+        m_owner->Open(kernel);
     }
 
     // Mark initialized.
     m_initialized = true;
 }
 
-void KEvent::Finalize() {
-    KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObjectWithList>::Finalize();
+void KEvent::Finalize(KernelCore& kernel) {
+    KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObjectWithList>::Finalize(kernel);
 }
 
-Result KEvent::Signal() {
-    KScopedSchedulerLock sl{m_kernel};
+Result KEvent::Signal(KernelCore& kernel) {
+    KScopedSchedulerLock sl{kernel};
 
     R_SUCCEED_IF(m_readable_event_destroyed);
 
-    return m_readable_event.Signal();
+    return m_readable_event.Signal(kernel);
 }
 
-Result KEvent::Clear() {
-    KScopedSchedulerLock sl{m_kernel};
+Result KEvent::Clear(KernelCore& kernel) {
+    KScopedSchedulerLock sl{kernel};
 
     R_SUCCEED_IF(m_readable_event_destroyed);
 
-    return m_readable_event.Clear();
+    return m_readable_event.Clear(kernel);
 }
 
-void KEvent::PostDestroy(uintptr_t arg) {
+void KEvent::PostDestroy(KernelCore& kernel, uintptr_t arg) {
     // Release the event count resource the owner process holds.
     KProcess* owner = reinterpret_cast<KProcess*>(arg);
 
     if (owner != nullptr) {
-        owner->GetResourceLimit()->Release(LimitableResource::EventCountMax, 1);
-        owner->Close();
+        owner->GetResourceLimit()->Release(kernel, LimitableResource::EventCountMax, 1);
+        owner->Close(kernel);
     }
 }