Kernel: replace usage of Core::System::GetInstance().PrepareReschedule() with callback

src/core/hle/kernel/kernel.cpp

@@ -16,8 +16,10 @@
 namespace Kernel {
 
 /// Initialize the kernel
-KernelSystem::KernelSystem(Memory::MemorySystem& memory, Core::Timing& timing, u32 system_mode)
-    : memory(memory), timing(timing) {
+KernelSystem::KernelSystem(Memory::MemorySystem& memory, Core::Timing& timing,
+                           std::function<void()> prepare_reschedule_callback, u32 system_mode)
+    : memory(memory), timing(timing),
+      prepare_reschedule_callback(std::move(prepare_reschedule_callback)) {
     MemoryInit(system_mode);
 
     resource_limits = std::make_unique<ResourceLimitList>(*this);

src/core/hle/kernel/kernel.h

@@ -6,6 +6,7 @@
 
 #include <array>
 #include <atomic>
+#include <functional>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -82,7 +83,8 @@ using SharedPtr = boost::intrusive_ptr<T>;
 
 class KernelSystem {
 public:
-    explicit KernelSystem(Memory::MemorySystem& memory, Core::Timing& timing, u32 system_mode);
+    explicit KernelSystem(Memory::MemorySystem& memory, Core::Timing& timing,
+                          std::function<void()> prepare_reschedule_callback, u32 system_mode);
     ~KernelSystem();
 
     /**
@@ -228,6 +230,10 @@ public:
     /// Adds a port to the named port table
     void AddNamedPort(std::string name, SharedPtr<ClientPort> port);
 
+    void PrepareReschedule() {
+        prepare_reschedule_callback();
+    }
+
     /// Map of named ports managed by the kernel, which can be retrieved using the ConnectToPort
     std::unordered_map<std::string, SharedPtr<ClientPort>> named_ports;
 
@@ -238,6 +244,8 @@ public:
 private:
     void MemoryInit(u32 mem_type);
 
+    std::function<void()> prepare_reschedule_callback;
+
     std::unique_ptr<ResourceLimitList> resource_limits;
     std::atomic<u32> next_object_id{0};
 

src/core/hle/kernel/mutex.cpp

@@ -24,7 +24,7 @@ void ReleaseThreadMutexes(Thread* thread) {
     thread->held_mutexes.clear();
 }
 
-Mutex::Mutex(KernelSystem& kernel) : WaitObject(kernel) {}
+Mutex::Mutex(KernelSystem& kernel) : WaitObject(kernel), kernel(kernel) {}
 Mutex::~Mutex() {}
 
 SharedPtr<Mutex> KernelSystem::CreateMutex(bool initial_locked, std::string name) {
@@ -54,7 +54,7 @@ void Mutex::Acquire(Thread* thread) {
         thread->held_mutexes.insert(this);
         holding_thread = thread;
         thread->UpdatePriority();
-        Core::System::GetInstance().PrepareReschedule();
+        kernel.PrepareReschedule();
     }
 
     lock_count++;
@@ -87,7 +87,7 @@ ResultCode Mutex::Release(Thread* thread) {
         holding_thread->UpdatePriority();
         holding_thread = nullptr;
         WakeupAllWaitingThreads();
-        Core::System::GetInstance().PrepareReschedule();
+        kernel.PrepareReschedule();
     }
 
     return RESULT_SUCCESS;

src/core/hle/kernel/mutex.h

@@ -57,6 +57,7 @@ private:
     ~Mutex() override;
 
     friend class KernelSystem;
+    KernelSystem& kernel;
 };
 
 /**

src/core/hle/kernel/thread.cpp

@@ -224,7 +224,7 @@ void Thread::ResumeFromWait() {
 
     thread_manager.ready_queue.push_back(current_priority, this);
     status = ThreadStatus::Ready;
-    Core::System::GetInstance().PrepareReschedule();
+    thread_manager.kernel.PrepareReschedule();
 }
 
 void ThreadManager::DebugThreadQueue() {