Merge pull request #4651 from lioncash/kernel-global

kernel: Remove all dependencies on the global system instance

src/core/hle/kernel/client_session.cpp

@@ -48,14 +48,15 @@ ResultVal<std::shared_ptr<ClientSession>> ClientSession::Create(KernelCore& kern
 }
 
 ResultCode ClientSession::SendSyncRequest(std::shared_ptr<Thread> thread,
-                                          Core::Memory::Memory& memory) {
+                                          Core::Memory::Memory& memory,
+                                          Core::Timing::CoreTiming& core_timing) {
     // Keep ServerSession alive until we're done working with it.
     if (!parent->Server()) {
         return ERR_SESSION_CLOSED_BY_REMOTE;
     }
 
     // Signal the server session that new data is available
-    return parent->Server()->HandleSyncRequest(std::move(thread), memory);
+    return parent->Server()->HandleSyncRequest(std::move(thread), memory, core_timing);
 }
 
 } // namespace Kernel

src/core/hle/kernel/client_session.h

@@ -16,6 +16,10 @@ namespace Core::Memory {
 class Memory;
 }
 
+namespace Core::Timing {
+class CoreTiming;
+}
+
 namespace Kernel {
 
 class KernelCore;
@@ -42,7 +46,8 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResultCode SendSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory);
+    ResultCode SendSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory,
+                               Core::Timing::CoreTiming& core_timing);
 
     bool ShouldWait(const Thread* thread) const override;
 

src/core/hle/kernel/server_session.cpp

@@ -8,7 +8,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
@@ -185,10 +184,11 @@ ResultCode ServerSession::CompleteSyncRequest() {
 }
 
 ResultCode ServerSession::HandleSyncRequest(std::shared_ptr<Thread> thread,
-                                            Core::Memory::Memory& memory) {
+                                            Core::Memory::Memory& memory,
+                                            Core::Timing::CoreTiming& core_timing) {
     const ResultCode result = QueueSyncRequest(std::move(thread), memory);
     const auto delay = std::chrono::nanoseconds{kernel.IsMulticore() ? 0 : 20000};
-    Core::System::GetInstance().CoreTiming().ScheduleEvent(delay, request_event, {});
+    core_timing.ScheduleEvent(delay, request_event, {});
     return result;
 }
 

src/core/hle/kernel/server_session.h

@@ -18,8 +18,9 @@ class Memory;
 }
 
 namespace Core::Timing {
+class CoreTiming;
 struct EventType;
-}
+} // namespace Core::Timing
 
 namespace Kernel {
 
@@ -89,10 +90,12 @@ public:
      *
      * @param thread      Thread that initiated the request.
      * @param memory      Memory context to handle the sync request under.
+     * @param core_timing Core timing context to schedule the request event under.
      *
      * @returns ResultCode from the operation.
      */
-    ResultCode HandleSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory);
+    ResultCode HandleSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory,
+                                 Core::Timing::CoreTiming& core_timing);
 
     bool ShouldWait(const Thread* thread) const override;
 

src/core/hle/kernel/svc.cpp

@@ -346,7 +346,7 @@ static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
         SchedulerLock lock(system.Kernel());
         thread->InvalidateHLECallback();
         thread->SetStatus(ThreadStatus::WaitIPC);
-        session->SendSyncRequest(SharedFrom(thread), system.Memory());
+        session->SendSyncRequest(SharedFrom(thread), system.Memory(), system.CoreTiming());
     }
 
     if (thread->HasHLECallback()) {