Service/AOC: stub ListAddOnContent function

Scheduler cleanup

src/common/logging/backend.cpp

@@ -35,6 +35,7 @@ namespace Log {
     SUB(Service, ACC)                                                                              \
     SUB(Service, Audio)                                                                            \
     SUB(Service, AM)                                                                               \
+    SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \

src/common/logging/log.h

@@ -51,6 +51,7 @@ enum class Class : ClassType {
                        ///  should have its own subclass.
     Service_ACC,       ///< The ACC (Accounts) service
     Service_AM,        ///< The AM (Applet manager) service
+    Service_AOC,       ///< The AOC (AddOn Content) service
     Service_APM,       ///< The APM (Performance) service
     Service_Audio,     ///< The Audio (Audio control) service
     Service_FS,        ///< The FS (Filesystem) service

src/core/CMakeLists.txt

@@ -28,8 +28,6 @@ add_library(core STATIC
     hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
-    hle/kernel/address_arbiter.cpp
-    hle/kernel/address_arbiter.h
     hle/kernel/client_port.cpp
     hle/kernel/client_port.h
     hle/kernel/client_session.cpp
@@ -55,6 +53,8 @@ add_library(core STATIC
     hle/kernel/process.h
     hle/kernel/resource_limit.cpp
     hle/kernel/resource_limit.h
+    hle/kernel/scheduler.cpp
+    hle/kernel/scheduler.h
     hle/kernel/server_port.cpp
     hle/kernel/server_port.h
     hle/kernel/server_session.cpp

src/core/core.cpp

@@ -133,7 +133,7 @@ void System::Reschedule() {
     }
 
     reschedule_pending = false;
-    Kernel::Reschedule();
+    Core::System::GetInstance().Scheduler().Reschedule();
 }
 
 System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
@@ -141,19 +141,20 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
 
     switch (Settings::values.cpu_core) {
     case Settings::CpuCore::Unicorn:
-        cpu_core = std::make_unique<ARM_Unicorn>();
+        cpu_core = std::make_shared<ARM_Unicorn>();
         break;
     case Settings::CpuCore::Dynarmic:
     default:
 #ifdef ARCHITECTURE_x86_64
-        cpu_core = std::make_unique<ARM_Dynarmic>();
+        cpu_core = std::make_shared<ARM_Dynarmic>();
 #else
-        cpu_core = std::make_unique<ARM_Unicorn>();
+        cpu_core = std::make_shared<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
         break;
     }
 
+    scheduler = std::make_unique<Kernel::Scheduler>(cpu_core.get());
     gpu_core = std::make_unique<Tegra::GPU>();
 
     telemetry_session = std::make_unique<Core::TelemetrySession>();

src/core/core.h

@@ -7,6 +7,7 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
+#include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 #include "core/perf_stats.h"
@@ -107,6 +108,10 @@ public:
         return *gpu_core;
     }
 
+    Kernel::Scheduler& Scheduler() {
+        return *scheduler;
+    }
+
     PerfStats perf_stats;
     FrameLimiter frame_limiter;
 
@@ -140,9 +145,8 @@ private:
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
 
-    ///< ARM11 CPU core
-    std::unique_ptr<ARM_Interface> cpu_core;
-
+    std::shared_ptr<ARM_Interface> cpu_core;
+    std::unique_ptr<Kernel::Scheduler> scheduler;
     std::unique_ptr<Tegra::GPU> gpu_core;
 
     /// When true, signals that a reschedule should happen

src/core/hle/kernel/address_arbiter.cpp

@@ -1,91 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/hle/kernel/address_arbiter.h"
-#include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/thread.h"
-#include "core/memory.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Kernel namespace
-
-namespace Kernel {
-
-AddressArbiter::AddressArbiter() {}
-AddressArbiter::~AddressArbiter() {}
-
-SharedPtr<AddressArbiter> AddressArbiter::Create(std::string name) {
-    SharedPtr<AddressArbiter> address_arbiter(new AddressArbiter);
-
-    address_arbiter->name = std::move(name);
-
-    return address_arbiter;
-}
-
-ResultCode AddressArbiter::ArbitrateAddress(ArbitrationType type, VAddr address, s32 value,
-                                            u64 nanoseconds) {
-    switch (type) {
-
-    // Signal thread(s) waiting for arbitrate address...
-    case ArbitrationType::Signal:
-        // Negative value means resume all threads
-        if (value < 0) {
-            ArbitrateAllThreads(address);
-        } else {
-            // Resume first N threads
-            for (int i = 0; i < value; i++)
-                ArbitrateHighestPriorityThread(address);
-        }
-        break;
-
-    // Wait current thread (acquire the arbiter)...
-    case ArbitrationType::WaitIfLessThan:
-        if ((s32)Memory::Read32(address) < value) {
-            Kernel::WaitCurrentThread_ArbitrateAddress(address);
-        }
-        break;
-    case ArbitrationType::WaitIfLessThanWithTimeout:
-        if ((s32)Memory::Read32(address) < value) {
-            Kernel::WaitCurrentThread_ArbitrateAddress(address);
-            GetCurrentThread()->WakeAfterDelay(nanoseconds);
-        }
-        break;
-    case ArbitrationType::DecrementAndWaitIfLessThan: {
-        s32 memory_value = Memory::Read32(address);
-        if (memory_value < value) {
-            // Only change the memory value if the thread should wait
-            Memory::Write32(address, (s32)memory_value - 1);
-            Kernel::WaitCurrentThread_ArbitrateAddress(address);
-        }
-        break;
-    }
-    case ArbitrationType::DecrementAndWaitIfLessThanWithTimeout: {
-        s32 memory_value = Memory::Read32(address);
-        if (memory_value < value) {
-            // Only change the memory value if the thread should wait
-            Memory::Write32(address, (s32)memory_value - 1);
-            Kernel::WaitCurrentThread_ArbitrateAddress(address);
-            GetCurrentThread()->WakeAfterDelay(nanoseconds);
-        }
-        break;
-    }
-
-    default:
-        LOG_ERROR(Kernel, "unknown type=%d", type);
-        return ERR_INVALID_ENUM_VALUE_FND;
-    }
-
-    // The calls that use a timeout seem to always return a Timeout error even if they did not put
-    // the thread to sleep
-    if (type == ArbitrationType::WaitIfLessThanWithTimeout ||
-        type == ArbitrationType::DecrementAndWaitIfLessThanWithTimeout) {
-
-        return RESULT_TIMEOUT;
-    }
-    return RESULT_SUCCESS;
-}
-
-} // namespace Kernel

src/core/hle/kernel/address_arbiter.h

@@ -1,60 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/result.h"
-
-// Address arbiters are an underlying kernel synchronization object that can be created/used via
-// supervisor calls (SVCs). They function as sort of a global lock. Typically, games/other CTR
-// applications use them as an underlying mechanism to implement thread-safe barriers, events, and
-// semphores.
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Kernel namespace
-
-namespace Kernel {
-
-enum class ArbitrationType : u32 {
-    Signal,
-    WaitIfLessThan,
-    DecrementAndWaitIfLessThan,
-    WaitIfLessThanWithTimeout,
-    DecrementAndWaitIfLessThanWithTimeout,
-};
-
-class AddressArbiter final : public Object {
-public:
-    /**
-     * Creates an address arbiter.
-     *
-     * @param name Optional name used for debugging.
-     * @returns The created AddressArbiter.
-     */
-    static SharedPtr<AddressArbiter> Create(std::string name = "Unknown");
-
-    std::string GetTypeName() const override {
-        return "Arbiter";
-    }
-    std::string GetName() const override {
-        return name;
-    }
-
-    static const HandleType HANDLE_TYPE = HandleType::AddressArbiter;
-    HandleType GetHandleType() const override {
-        return HANDLE_TYPE;
-    }
-
-    std::string name; ///< Name of address arbiter object (optional)
-
-    ResultCode ArbitrateAddress(ArbitrationType type, VAddr address, s32 value, u64 nanoseconds);
-
-private:
-    AddressArbiter();
-    ~AddressArbiter() override;
-};
-
-} // namespace Kernel

src/core/hle/kernel/hle_ipc.cpp

@@ -254,4 +254,55 @@ size_t HLERequestContext::GetWriteBufferSize() const {
     return is_buffer_b ? BufferDescriptorB()[0].Size() : BufferDescriptorC()[0].Size();
 }
 
+std::string HLERequestContext::Description() const {
+    if (!command_header) {
+        return "No command header available";
+    }
+    std::ostringstream s;
+    s << "IPC::CommandHeader: Type:" << static_cast<u32>(command_header->type.Value());
+    s << ", X(Pointer):" << command_header->num_buf_x_descriptors;
+    if (command_header->num_buf_x_descriptors) {
+        s << '[';
+        for (u64 i = 0; i < command_header->num_buf_x_descriptors; ++i) {
+            s << "0x" << std::hex << BufferDescriptorX()[i].Size();
+            if (i < command_header->num_buf_x_descriptors - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", A(Send):" << command_header->num_buf_a_descriptors;
+    if (command_header->num_buf_a_descriptors) {
+        s << '[';
+        for (u64 i = 0; i < command_header->num_buf_a_descriptors; ++i) {
+            s << "0x" << std::hex << BufferDescriptorA()[i].Size();
+            if (i < command_header->num_buf_a_descriptors - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", B(Receive):" << command_header->num_buf_b_descriptors;
+    if (command_header->num_buf_b_descriptors) {
+        s << '[';
+        for (u64 i = 0; i < command_header->num_buf_b_descriptors; ++i) {
+            s << "0x" << std::hex << BufferDescriptorB()[i].Size();
+            if (i < command_header->num_buf_b_descriptors - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", C(ReceiveList):" << BufferDescriptorC().size();
+    if (!BufferDescriptorC().empty()) {
+        s << '[';
+        for (u64 i = 0; i < BufferDescriptorC().size(); ++i) {
+            s << "0x" << std::hex << BufferDescriptorC()[i].Size();
+            if (i < BufferDescriptorC().size() - 1)
+                s << ", ";
+        }
+        s << ']';
+    }
+    s << ", data_size:" << command_header->data_size.Value();
+
+    return s.str();
+}
+
 } // namespace Kernel

src/core/hle/kernel/hle_ipc.h

@@ -202,6 +202,8 @@ public:
         return domain_objects.size();
     }
 
+    std::string Description() const;
+
 private:
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
     SharedPtr<Kernel::ServerSession> server_session;

src/core/hle/kernel/scheduler.cpp

@@ -0,0 +1,134 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/core_timing.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/kernel/scheduler.h"
+
+namespace Kernel {
+
+Scheduler::Scheduler(ARM_Interface* cpu_core) : cpu_core(cpu_core) {}
+
+Scheduler::~Scheduler() {
+    for (auto& thread : thread_list) {
+        thread->Stop();
+    }
+}
+
+bool Scheduler::HaveReadyThreads() {
+    return ready_queue.get_first() != nullptr;
+}
+
+Thread* Scheduler::GetCurrentThread() const {
+    return current_thread.get();
+}
+
+Thread* Scheduler::PopNextReadyThread() {
+    Thread* next = nullptr;
+    Thread* thread = GetCurrentThread();
+
+    if (thread && thread->status == THREADSTATUS_RUNNING) {
+        // We have to do better than the current thread.
+        // This call returns null when that's not possible.
+        next = ready_queue.pop_first_better(thread->current_priority);
+        if (!next) {
+            // Otherwise just keep going with the current thread
+            next = thread;
+        }
+    } else {
+        next = ready_queue.pop_first();
+    }
+
+    return next;
+}
+
+void Scheduler::SwitchContext(Thread* new_thread) {
+    Thread* previous_thread = GetCurrentThread();
+
+    // Save context for previous thread
+    if (previous_thread) {
+        previous_thread->last_running_ticks = CoreTiming::GetTicks();
+        cpu_core->SaveContext(previous_thread->context);
+
+        if (previous_thread->status == THREADSTATUS_RUNNING) {
+            // This is only the case when a reschedule is triggered without the current thread
+            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
+            ready_queue.push_front(previous_thread->current_priority, previous_thread);
+            previous_thread->status = THREADSTATUS_READY;
+        }
+    }
+
+    // Load context of new thread
+    if (new_thread) {
+        ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
+                   "Thread must be ready to become running.");
+
+        // Cancel any outstanding wakeup events for this thread
+        new_thread->CancelWakeupTimer();
+
+        auto previous_process = Kernel::g_current_process;
+
+        current_thread = new_thread;
+
+        ready_queue.remove(new_thread->current_priority, new_thread);
+        new_thread->status = THREADSTATUS_RUNNING;
+
+        if (previous_process != current_thread->owner_process) {
+            Kernel::g_current_process = current_thread->owner_process;
+            SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
+        }
+
+        cpu_core->LoadContext(new_thread->context);
+        cpu_core->SetTlsAddress(new_thread->GetTLSAddress());
+    } else {
+        current_thread = nullptr;
+        // Note: We do not reset the current process and current page table when idling because
+        // technically we haven't changed processes, our threads are just paused.
+    }
+}
+
+void Scheduler::Reschedule() {
+    Thread* cur = GetCurrentThread();
+    Thread* next = PopNextReadyThread();
+
+    if (cur && next) {
+        LOG_TRACE(Kernel, "context switch %u -> %u", cur->GetObjectId(), next->GetObjectId());
+    } else if (cur) {
+        LOG_TRACE(Kernel, "context switch %u -> idle", cur->GetObjectId());
+    } else if (next) {
+        LOG_TRACE(Kernel, "context switch idle -> %u", next->GetObjectId());
+    }
+
+    SwitchContext(next);
+}
+
+void Scheduler::AddThread(SharedPtr<Thread> thread, u32 priority) {
+    thread_list.push_back(thread);
+    ready_queue.prepare(priority);
+}
+
+void Scheduler::RemoveThread(Thread* thread) {
+    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
+                      thread_list.end());
+}
+
+void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
+    ASSERT(thread->status == THREADSTATUS_READY);
+    ready_queue.push_back(priority, thread);
+}
+
+void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
+    ASSERT(thread->status == THREADSTATUS_READY);
+    ready_queue.remove(priority, thread);
+}
+
+void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
+    // If thread was ready, adjust queues
+    if (thread->status == THREADSTATUS_READY)
+        ready_queue.move(thread, thread->current_priority, priority);
+    else
+        ready_queue.prepare(priority);
+}
+
+} // namespace Kernel

src/core/hle/kernel/scheduler.h

@@ -0,0 +1,73 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+#include "common/common_types.h"
+#include "common/thread_queue_list.h"
+#include "core/arm/arm_interface.h"
+#include "core/hle/kernel/thread.h"
+
+namespace Kernel {
+
+class Scheduler final {
+public:
+    explicit Scheduler(ARM_Interface* cpu_core);
+    ~Scheduler();
+
+    /// Returns whether there are any threads that are ready to run.
+    bool HaveReadyThreads();
+
+    /// Reschedules to the next available thread (call after current thread is suspended)
+    void Reschedule();
+
+    /// Gets the current running thread
+    Thread* GetCurrentThread() const;
+
+    /// Adds a new thread to the scheduler
+    void AddThread(SharedPtr<Thread> thread, u32 priority);
+
+    /// Removes a thread from the scheduler
+    void RemoveThread(Thread* thread);
+
+    /// Schedules a thread that has become "ready"
+    void ScheduleThread(Thread* thread, u32 priority);
+
+    /// Unschedules a thread that was already scheduled
+    void UnscheduleThread(Thread* thread, u32 priority);
+
+    /// Sets the priority of a thread in the scheduler
+    void SetThreadPriority(Thread* thread, u32 priority);
+
+    /// Returns a list of all threads managed by the scheduler
+    const std::vector<SharedPtr<Thread>>& GetThreadList() const {
+        return thread_list;
+    }
+
+private:
+    /**
+     * Pops and returns the next thread from the thread queue
+     * @return A pointer to the next ready thread
+     */
+    Thread* PopNextReadyThread();
+
+    /**
+     * Switches the CPU's active thread context to that of the specified thread
+     * @param new_thread The thread to switch to
+     */
+    void SwitchContext(Thread* new_thread);
+
+    /// Lists all thread ids that aren't deleted/etc.
+    std::vector<SharedPtr<Thread>> thread_list;
+
+    /// Lists only ready thread ids.
+    Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
+
+    SharedPtr<Thread> current_thread = nullptr;
+
+    ARM_Interface* cpu_core;
+};
+
+} // namespace Kernel

src/core/hle/kernel/server_session.cpp

@@ -57,6 +57,33 @@ void ServerSession::Acquire(Thread* thread) {
     pending_requesting_threads.pop_back();
 }
 
+ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
+    auto& domain_message_header = context.GetDomainMessageHeader();
+    if (domain_message_header) {
+        // If there is a DomainMessageHeader, then this is CommandType "Request"
+        const u32 object_id{context.GetDomainMessageHeader()->object_id};
+        switch (domain_message_header->command) {
+        case IPC::DomainMessageHeader::CommandType::SendMessage:
+            return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
+
+        case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
+            LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
+
+            domain_request_handlers[object_id - 1] = nullptr;
+
+            IPC::ResponseBuilder rb{context, 2};
+            rb.Push(RESULT_SUCCESS);
+            return RESULT_SUCCESS;
+        }
+        }
+
+        LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
+        ASSERT(false);
+    }
+
+    return RESULT_SUCCESS;
+}
+
 ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // The ServerSession received a sync request, this means that there's new data available
     // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or
@@ -67,46 +94,39 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     context.PopulateFromIncomingCommandBuffer(cmd_buf, *Kernel::g_current_process,
                                               Kernel::g_handle_table);
 
-    // If the session has been converted to a domain, handle the doomain request
+    ResultCode result = RESULT_SUCCESS;
+    // If the session has been converted to a domain, handle the domain request
     if (IsDomain()) {
-        auto& domain_message_header = context.GetDomainMessageHeader();
-        if (domain_message_header) {
-            // If there is a DomainMessageHeader, then this is CommandType "Request"
-            const u32 object_id{context.GetDomainMessageHeader()->object_id};
-            switch (domain_message_header->command) {
-            case IPC::DomainMessageHeader::CommandType::SendMessage:
-                return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
-
-            case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
-                LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x%08X", object_id);
-
-                domain_request_handlers[object_id - 1] = nullptr;
-
-                IPC::ResponseBuilder rb{context, 2};
-                rb.Push(RESULT_SUCCESS);
-                return RESULT_SUCCESS;
-            }
-            }
-
-            LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
-            ASSERT(false);
-        }
+        result = HandleDomainSyncRequest(context);
         // If there is no domain header, the regular session handler is used
+    } else if (hle_handler != nullptr) {
+        // If this ServerSession has an associated HLE handler, forward the request to it.
+        result = hle_handler->HandleSyncRequest(context);
     }
 
-    // If this ServerSession has an associated HLE handler, forward the request to it.
-    ResultCode result{RESULT_SUCCESS};
-    if (hle_handler != nullptr) {
-        // Attempt to translate the incoming request's command buffer.
-        ResultCode translate_result = TranslateHLERequest(this);
-        if (translate_result.IsError())
-            return translate_result;
+    if (thread->status == THREADSTATUS_RUNNING) {
+        // Put the thread to sleep until the server replies, it will be awoken in
+        // svcReplyAndReceive for LLE servers.
+        thread->status = THREADSTATUS_WAIT_IPC;
 
-        result = hle_handler->HandleSyncRequest(context);
-    } else {
-        // Add the thread to the list of threads that have issued a sync request with this
-        // server.
-        pending_requesting_threads.push_back(std::move(thread));
+        if (hle_handler != nullptr) {
+            // For HLE services, we put the request threads to sleep for a short duration to
+            // simulate IPC overhead, but only if the HLE handler didn't put the thread to sleep for
+            // other reasons like an async callback. The IPC overhead is needed to prevent
+            // starvation when a thread only does sync requests to HLE services while a
+            // lower-priority thread is waiting to run.
+
+            // This delay was approximated in a homebrew application by measuring the average time
+            // it takes for svcSendSyncRequest to return when performing the SetLcdForceBlack IPC
+            // request to the GSP:GPU service in a n3DS with firmware 11.6. The measured values have
+            // a high variance and vary between models.
+            static constexpr u64 IPCDelayNanoseconds = 39000;
+            thread->WakeAfterDelay(IPCDelayNanoseconds);
+        } else {
+            // Add the thread to the list of threads that have issued a sync request with this
+            // server.
+            pending_requesting_threads.push_back(std::move(thread));
+        }
     }
 
     // If this ServerSession does not have an HLE implementation, just wake up the threads waiting
@@ -140,9 +160,4 @@ ServerSession::SessionPair ServerSession::CreateSessionPair(const std::string& n
 
     return std::make_tuple(std::move(server_session), std::move(client_session));
 }
-
-ResultCode TranslateHLERequest(ServerSession* server_session) {
-    // TODO(Subv): Implement this function once multiple concurrent processes are supported.
-    return RESULT_SUCCESS;
-}
 } // namespace Kernel

src/core/hle/kernel/server_session.h

@@ -21,6 +21,7 @@ class ServerSession;
 class Session;
 class SessionRequestHandler;
 class Thread;
+class HLERequestContext;
 
 /**
  * Kernel object representing the server endpoint of an IPC session. Sessions are the basic CTR-OS
@@ -116,17 +117,12 @@ private:
      */
     static ResultVal<SharedPtr<ServerSession>> Create(std::string name = "Unknown");
 
+    /// Handles a SyncRequest to a domain, forwarding the request to the proper object or closing an
+    /// object handle.
+    ResultCode HandleDomainSyncRequest(Kernel::HLERequestContext& context);
+
     /// When set to True, converts the session to a domain at the end of the command
     bool convert_to_domain{};
 };
 
-/**
- * Performs command buffer translation for an HLE IPC request.
- * The command buffer from the ServerSession thread's TLS is copied into a
- * buffer and all descriptors in the buffer are processed.
- * TODO(Subv): Implement this function, currently we do not support multiple processes running at
- * once, but once that is implemented we'll need to properly translate all descriptors
- * in the command buffer.
- */
-ResultCode TranslateHLERequest(ServerSession* server_session);
 } // namespace Kernel

src/core/hle/kernel/svc.cpp

@@ -483,7 +483,7 @@ static void ExitProcess() {
     g_current_process->status = ProcessStatus::Exited;
 
     // Stop all the process threads that are currently waiting for objects.
-    auto& thread_list = GetThreadList();
+    auto& thread_list = Core::System::GetInstance().Scheduler().GetThreadList();
     for (auto& thread : thread_list) {
         if (thread->owner_process != g_current_process)
             continue;
@@ -585,7 +585,7 @@ static void SleepThread(s64 nanoseconds) {
 
     // Don't attempt to yield execution if there are no available threads to run,
     // this way we avoid a useless reschedule to the idle thread.
-    if (nanoseconds == 0 && !HaveReadyThreads())
+    if (nanoseconds == 0 && !Core::System::GetInstance().Scheduler().HaveReadyThreads())
         return;
 
     // Sleep current thread and check for next thread to schedule

src/core/hle/kernel/thread.cpp

@@ -41,14 +41,6 @@ void Thread::Acquire(Thread* thread) {
 //               us to simply use a pool index or similar.
 static Kernel::HandleTable wakeup_callback_handle_table;
 
-// Lists all thread ids that aren't deleted/etc.
-static std::vector<SharedPtr<Thread>> thread_list;
-
-// Lists only ready thread ids.
-static Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
-
-static SharedPtr<Thread> current_thread;
-
 // The first available thread id at startup
 static u32 next_thread_id;
 
@@ -63,10 +55,6 @@ inline static u32 const NewThreadId() {
 Thread::Thread() {}
 Thread::~Thread() {}
 
-Thread* GetCurrentThread() {
-    return current_thread.get();
-}
-
 /**
  * Check if the specified thread is waiting on the specified address to be arbitrated
  * @param thread The thread to test
@@ -86,7 +74,7 @@ void Thread::Stop() {
     // Clean up thread from ready queue
     // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
     if (status == THREADSTATUS_READY) {
-        ready_queue.remove(current_priority, this);
+        Core::System::GetInstance().Scheduler().UnscheduleThread(this, current_priority);
     }
 
     status = THREADSTATUS_DEAD;
@@ -109,112 +97,6 @@ void Thread::Stop() {
     Kernel::g_current_process->tls_slots[tls_page].reset(tls_slot);
 }
 
-Thread* ArbitrateHighestPriorityThread(u32 address) {
-    Thread* highest_priority_thread = nullptr;
-    u32 priority = THREADPRIO_LOWEST;
-
-    // Iterate through threads, find highest priority thread that is waiting to be arbitrated...
-    for (auto& thread : thread_list) {
-        if (!CheckWait_AddressArbiter(thread.get(), address))
-            continue;
-
-        if (thread == nullptr)
-            continue;
-
-        if (thread->current_priority <= priority) {
-            highest_priority_thread = thread.get();
-            priority = thread->current_priority;
-        }
-    }
-
-    // If a thread was arbitrated, resume it
-    if (nullptr != highest_priority_thread) {
-        highest_priority_thread->ResumeFromWait();
-    }
-
-    return highest_priority_thread;
-}
-
-void ArbitrateAllThreads(u32 address) {
-    // Resume all threads found to be waiting on the address
-    for (auto& thread : thread_list) {
-        if (CheckWait_AddressArbiter(thread.get(), address))
-            thread->ResumeFromWait();
-    }
-}
-
-/**
- * Switches the CPU's active thread context to that of the specified thread
- * @param new_thread The thread to switch to
- */
-static void SwitchContext(Thread* new_thread) {
-    Thread* previous_thread = GetCurrentThread();
-
-    // Save context for previous thread
-    if (previous_thread) {
-        previous_thread->last_running_ticks = CoreTiming::GetTicks();
-        Core::CPU().SaveContext(previous_thread->context);
-
-        if (previous_thread->status == THREADSTATUS_RUNNING) {
-            // This is only the case when a reschedule is triggered without the current thread
-            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
-            ready_queue.push_front(previous_thread->current_priority, previous_thread);
-            previous_thread->status = THREADSTATUS_READY;
-        }
-    }
-
-    // Load context of new thread
-    if (new_thread) {
-        ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
-                   "Thread must be ready to become running.");
-
-        // Cancel any outstanding wakeup events for this thread
-        CoreTiming::UnscheduleEvent(ThreadWakeupEventType, new_thread->callback_handle);
-
-        auto previous_process = Kernel::g_current_process;
-
-        current_thread = new_thread;
-
-        ready_queue.remove(new_thread->current_priority, new_thread);
-        new_thread->status = THREADSTATUS_RUNNING;
-
-        if (previous_process != current_thread->owner_process) {
-            Kernel::g_current_process = current_thread->owner_process;
-            SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
-        }
-
-        Core::CPU().LoadContext(new_thread->context);
-        Core::CPU().SetTlsAddress(new_thread->GetTLSAddress());
-    } else {
-        current_thread = nullptr;
-        // Note: We do not reset the current process and current page table when idling because
-        // technically we haven't changed processes, our threads are just paused.
-    }
-}
-
-/**
- * Pops and returns the next thread from the thread queue
- * @return A pointer to the next ready thread
- */
-static Thread* PopNextReadyThread() {
-    Thread* next;
-    Thread* thread = GetCurrentThread();
-
-    if (thread && thread->status == THREADSTATUS_RUNNING) {
-        // We have to do better than the current thread.
-        // This call returns null when that's not possible.
-        next = ready_queue.pop_first_better(thread->current_priority);
-        if (!next) {
-            // Otherwise just keep going with the current thread
-            next = thread;
-        }
-    } else {
-        next = ready_queue.pop_first();
-    }
-
-    return next;
-}
-
 void WaitCurrentThread_Sleep() {
     Thread* thread = GetCurrentThread();
     thread->status = THREADSTATUS_WAIT_SLEEP;
@@ -229,8 +111,7 @@ void WaitCurrentThread_ArbitrateAddress(VAddr wait_address) {
 void ExitCurrentThread() {
     Thread* thread = GetCurrentThread();
     thread->Stop();
-    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
-                      thread_list.end());
+    Core::System::GetInstance().Scheduler().RemoveThread(thread);
 }
 
 /**
@@ -284,6 +165,7 @@ void Thread::ResumeFromWait() {
     case THREADSTATUS_WAIT_SYNCH_ANY:
     case THREADSTATUS_WAIT_ARB:
     case THREADSTATUS_WAIT_SLEEP:
+    case THREADSTATUS_WAIT_IPC:
         break;
 
     case THREADSTATUS_READY:
@@ -307,31 +189,11 @@ void Thread::ResumeFromWait() {
 
     wakeup_callback = nullptr;
 
-    ready_queue.push_back(current_priority, this);
     status = THREADSTATUS_READY;
+    Core::System::GetInstance().Scheduler().ScheduleThread(this, current_priority);
     Core::System::GetInstance().PrepareReschedule();
 }
 
-/**
- * Prints the thread queue for debugging purposes
- */
-static void DebugThreadQueue() {
-    Thread* thread = GetCurrentThread();
-    if (!thread) {
-        LOG_DEBUG(Kernel, "Current: NO CURRENT THREAD");
-    } else {
-        LOG_DEBUG(Kernel, "0x%02X %u (current)", thread->current_priority,
-                  GetCurrentThread()->GetObjectId());
-    }
-
-    for (auto& t : thread_list) {
-        u32 priority = ready_queue.contains(t.get());
-        if (priority != -1) {
-            LOG_DEBUG(Kernel, "0x%02X %u", priority, t->GetObjectId());
-        }
-    }
-}
-
 /**
  * Finds a free location for the TLS section of a thread.
  * @param tls_slots The TLS page array of the thread's owner process.
@@ -399,8 +261,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
 
     SharedPtr<Thread> thread(new Thread);
 
-    thread_list.push_back(thread);
-    ready_queue.prepare(priority);
+    Core::System::GetInstance().Scheduler().AddThread(thread, priority);
 
     thread->thread_id = NewThreadId();
     thread->status = THREADSTATUS_DORMANT;
@@ -471,12 +332,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
 void Thread::SetPriority(u32 priority) {
     ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
                "Invalid priority value.");
-    // If thread was ready, adjust queues
-    if (status == THREADSTATUS_READY)
-        ready_queue.move(this, current_priority, priority);
-    else
-        ready_queue.prepare(priority);
-
+    Core::System::GetInstance().Scheduler().SetThreadPriority(this, priority);
     nominal_priority = current_priority = priority;
 }
 
@@ -490,11 +346,7 @@ void Thread::UpdatePriority() {
 }
 
 void Thread::BoostPriority(u32 priority) {
-    // If thread was ready, adjust queues
-    if (status == THREADSTATUS_READY)
-        ready_queue.move(this, current_priority, priority);
-    else
-        ready_queue.prepare(priority);
+    Core::System::GetInstance().Scheduler().SetThreadPriority(this, priority);
     current_priority = priority;
 }
 
@@ -520,25 +372,6 @@ SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
     return thread;
 }
 
-bool HaveReadyThreads() {
-    return ready_queue.get_first() != nullptr;
-}
-
-void Reschedule() {
-    Thread* cur = GetCurrentThread();
-    Thread* next = PopNextReadyThread();
-
-    if (cur && next) {
-        LOG_TRACE(Kernel, "context switch %u -> %u", cur->GetObjectId(), next->GetObjectId());
-    } else if (cur) {
-        LOG_TRACE(Kernel, "context switch %u -> idle", cur->GetObjectId());
-    } else if (next) {
-        LOG_TRACE(Kernel, "context switch idle -> %u", next->GetObjectId());
-    }
-
-    SwitchContext(next);
-}
-
 void Thread::SetWaitSynchronizationResult(ResultCode result) {
     context.cpu_registers[0] = result.raw;
 }
@@ -561,25 +394,18 @@ VAddr Thread::GetCommandBufferAddress() const {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+/**
+ * Gets the current thread
+ */
+Thread* GetCurrentThread() {
+    return Core::System::GetInstance().Scheduler().GetCurrentThread();
+}
+
 void ThreadingInit() {
     ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
-
-    current_thread = nullptr;
     next_thread_id = 1;
 }
 
-void ThreadingShutdown() {
-    current_thread = nullptr;
-
-    for (auto& t : thread_list) {
-        t->Stop();
-    }
-    thread_list.clear();
-    ready_queue.clear();
-}
-
-const std::vector<SharedPtr<Thread>>& GetThreadList() {
-    return thread_list;
-}
+void ThreadingShutdown() {}
 
 } // namespace Kernel

src/core/hle/kernel/thread.h

@@ -40,6 +40,7 @@ enum ThreadStatus {
     THREADSTATUS_READY,          ///< Ready to run
     THREADSTATUS_WAIT_ARB,       ///< Waiting on an address arbiter
     THREADSTATUS_WAIT_SLEEP,     ///< Waiting due to a SleepThread SVC
+    THREADSTATUS_WAIT_IPC,       ///< Waiting for the reply from an IPC request
     THREADSTATUS_WAIT_SYNCH_ANY, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
     THREADSTATUS_WAIT_SYNCH_ALL, ///< Waiting due to WaitSynchronizationN with wait_all = true
     THREADSTATUS_DORMANT,        ///< Created but not yet made ready
@@ -248,28 +249,6 @@ private:
 SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
                                   SharedPtr<Process> owner_process);
 
-/**
- * Returns whether there are any threads that are ready to run.
- */
-bool HaveReadyThreads();
-
-/**
- * Reschedules to the next available thread (call after current thread is suspended)
- */
-void Reschedule();
-
-/**
- * Arbitrate the highest priority thread that is waiting
- * @param address The address for which waiting threads should be arbitrated
- */
-Thread* ArbitrateHighestPriorityThread(VAddr address);
-
-/**
- * Arbitrate all threads currently waiting.
- * @param address The address for which waiting threads should be arbitrated
- */
-void ArbitrateAllThreads(VAddr address);
-
 /**
  * Gets the current thread
  */
@@ -301,9 +280,4 @@ void ThreadingInit();
  */
 void ThreadingShutdown();
 
-/**
- * Get a const reference to the thread list for debug use
- */
-const std::vector<SharedPtr<Thread>>& GetThreadList();
-
 } // namespace Kernel

src/core/hle/service/am/am.cpp

@@ -378,8 +378,9 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
 
 void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
+    IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
+    rb.Push<u64>(0);
 }
 
 void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {

src/core/hle/service/aoc/aoc_u.cpp

@@ -2,16 +2,37 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/aoc/aoc_u.h"
 
 namespace Service {
 namespace AOC {
 
+AOC_U::AOC_U() : ServiceFramework("aoc:u") {
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "CountAddOnContentByApplicationId"},
+        {1, nullptr, "ListAddOnContentByApplicationId"},
+        {2, nullptr, "CountAddOnContent"},
+        {3, &AOC_U::ListAddOnContent, "ListAddOnContent"},
+        {4, nullptr, "GetAddOnContentBaseIdByApplicationId"},
+        {5, nullptr, "GetAddOnContentBaseId"},
+        {6, nullptr, "PrepareAddOnContentByApplicationId"},
+        {7, nullptr, "PrepareAddOnContent"},
+    };
+    RegisterHandlers(functions);
+}
+
+void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push<u64>(0);
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+}
+
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AOC_U>()->InstallAsService(service_manager);
 }
 
-AOC_U::AOC_U() : ServiceFramework("aoc:u") {}
-
 } // namespace AOC
 } // namespace Service

src/core/hle/service/aoc/aoc_u.h

@@ -13,6 +13,9 @@ class AOC_U final : public ServiceFramework<AOC_U> {
 public:
     AOC_U();
     ~AOC_U() = default;
+
+private:
+    void ListAddOnContent(Kernel::HLERequestContext& ctx);
 };
 
 /// Registers all AOC services with the specified service manager.

src/core/hle/service/audio/audren_u.cpp

@@ -53,7 +53,8 @@ private:
     }
 
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
-        AudioRendererResponseData response_data = {0};
+        LOG_DEBUG(Service_Audio, "%s", ctx.Description().c_str());
+        AudioRendererResponseData response_data{};
 
         response_data.section_0_size =
             response_data.state_entries.size() * sizeof(AudioRendererStateEntry);

src/core/hle/service/hid/hid.cpp

@@ -176,7 +176,10 @@ public:
             {0, &Hid::CreateAppletResource, "CreateAppletResource"},
             {1, &Hid::ActivateDebugPad, "ActivateDebugPad"},
             {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
+            {21, &Hid::ActivateMouse, "ActivateMouse"},
+            {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
             {66, &Hid::StartSixAxisSensor, "StartSixAxisSensor"},
+            {79, &Hid::SetGyroscopeZeroDriftMode, "SetGyroscopeZeroDriftMode"},
             {100, &Hid::SetSupportedNpadStyleSet, "SetSupportedNpadStyleSet"},
             {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
             {103, &Hid::ActivateNpad, "ActivateNpad"},
@@ -184,9 +187,13 @@ public:
              "AcquireNpadStyleSetUpdateEventHandle"},
             {120, &Hid::SetNpadJoyHoldType, "SetNpadJoyHoldType"},
             {121, &Hid::GetNpadJoyHoldType, "GetNpadJoyHoldType"},
+            {122, &Hid::SetNpadJoyAssignmentModeSingleByDefault,
+             "SetNpadJoyAssignmentModeSingleByDefault"},
             {124, nullptr, "SetNpadJoyAssignmentModeDual"},
             {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
             {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
+            {201, &Hid::SendVibrationValue, "SendVibrationValue"},
+            {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
             {203, &Hid::CreateActiveVibrationDeviceList, "CreateActiveVibrationDeviceList"},
             {206, &Hid::SendVibrationValues, "SendVibrationValues"},
         };
@@ -224,12 +231,30 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void ActivateMouse(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
+    void ActivateKeyboard(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
     void StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
     void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -268,6 +293,24 @@ private:
         LOG_WARNING(Service_HID, "(STUBBED) called");
     }
 
+    void SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
+    void SendVibrationValue(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
+    void GetActualVibrationValue(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_HID, "(STUBBED) called");
+    }
+
     void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);

src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -17,6 +17,8 @@ u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<
     switch (static_cast<IoctlCommand>(command.raw)) {
     case IoctlCommand::IocGetConfigCommand:
         return NvOsGetConfigU32(input, output);
+    case IoctlCommand::IocCtrlEventWaitCommand:
+        return IocCtrlEventWait(input, output);
     }
     UNIMPLEMENTED();
     return 0;
@@ -45,6 +47,18 @@ u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>&
     return 0;
 }
 
+u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output) {
+    IocCtrlEventWaitParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called, syncpt_id=%u threshold=%u timeout=%d",
+                params.syncpt_id, params.threshold, params.timeout);
+
+    // TODO(Subv): Implement actual syncpt waiting.
+    params.value = 0;
+    std::memcpy(output.data(), &params, sizeof(params));
+    return 0;
+}
+
 } // namespace Devices
 } // namespace Nvidia
 } // namespace Service

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -31,6 +31,7 @@ private:
         IocModuleRegRDWRCommand = 0xC008010E,
         IocSyncptWaitexCommand = 0xC0100019,
         IocSyncptReadMaxCommand = 0xC008001A,
+        IocCtrlEventWaitCommand = 0xC010001D,
         IocGetConfigCommand = 0xC183001B,
     };
 
@@ -41,7 +42,17 @@ private:
     };
     static_assert(sizeof(IocGetConfigParams) == 387, "IocGetConfigParams is incorrect size");
 
+    struct IocCtrlEventWaitParams {
+        u32_le syncpt_id;
+        u32_le threshold;
+        s32_le timeout;
+        u32_le value;
+    };
+    static_assert(sizeof(IocCtrlEventWaitParams) == 16, "IocCtrlEventWaitParams is incorrect size");
+
     u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
+
+    u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Devices

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -103,11 +103,8 @@ u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
                             [&](const auto& entry) { return entry.second->id == params.id; });
     ASSERT(itr != handles.end());
 
-    // Make a new handle for the object
-    u32 handle = next_handle++;
-    handles[handle] = itr->second;
-
-    params.handle = handle;
+    // Return the existing handle instead of creating a new one.
+    params.handle = itr->first;
 
     std::memcpy(output.data(), &params, sizeof(params));
     return 0;

src/core/hle/service/nvdrv/nvdrv.h

@@ -17,6 +17,13 @@ namespace Devices {
 class nvdevice;
 }
 
+struct IoctlFence {
+    u32 id;
+    u32 value;
+};
+
+static_assert(sizeof(IoctlFence) == 8, "IoctlFence has wrong size");
+
 class Module final {
 public:
     Module();

src/core/hle/service/vi/vi.cpp

@@ -8,6 +8,7 @@
 #include "common/scope_exit.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/hle/service/vi/vi_m.h"
@@ -38,6 +39,7 @@ public:
 
     template <typename T>
     T Read() {
+        ASSERT(read_index + sizeof(T) <= buffer.size());
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -47,6 +49,7 @@ public:
 
     template <typename T>
     T ReadUnaligned() {
+        ASSERT(read_index + sizeof(T) <= buffer.size());
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -54,6 +57,7 @@ public:
     }
 
     std::vector<u8> ReadBlock(size_t length) {
+        ASSERT(read_index + length <= buffer.size());
         const u8* const begin = buffer.data() + read_index;
         const u8* const end = begin + length;
         std::vector<u8> data(begin, end);
@@ -86,7 +90,18 @@ public:
         write_index = Common::AlignUp(write_index, 4);
     }
 
+    template <typename T>
+    void WriteObject(const T& val) {
+        u32_le size = static_cast<u32>(sizeof(val));
+        Write(size);
+        // TODO(Subv): Support file descriptors.
+        Write<u32_le>(0); // Fd count.
+        Write(val);
+    }
+
     void Deserialize() {
+        ASSERT(buffer.size() > sizeof(Header));
+
         Header header{};
         std::memcpy(&header, buffer.data(), sizeof(Header));
 
@@ -262,10 +277,11 @@ public:
     Data data;
 };
 
-// TODO(bunnei): Remove this. When set to 1, games will think a fence is valid and boot further.
-// This will break libnx and potentially other apps that more stringently check this. This is here
-// purely as a convenience, and should go away once we implement fences.
-static constexpr u32 FENCE_HACK = 0;
+struct BufferProducerFence {
+    u32 is_valid;
+    std::array<Nvidia::IoctlFence, 4> fences;
+};
+static_assert(sizeof(BufferProducerFence) == 36, "BufferProducerFence has wrong size");
 
 class IGBPDequeueBufferResponseParcel : public Parcel {
 public:
@@ -274,20 +290,16 @@ public:
 
 protected:
     void SerializeData() override {
-        // TODO(bunnei): Find out what this all means. Writing anything non-zero here breaks libnx.
-        Write<u32>(0);
-        Write<u32>(FENCE_HACK);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
-        Write<u32>(0);
+        // TODO(Subv): Find out how this Fence is used.
+        BufferProducerFence fence = {};
+        fence.is_valid = 1;
+        for (auto& fence_ : fence.fences)
+            fence_.id = -1;
+
+        Write(slot);
+        Write<u32_le>(1);
+        WriteObject(fence);
+        Write<u32_le>(0);
     }
 
     u32_le slot;
@@ -316,11 +328,10 @@ public:
 
 protected:
     void SerializeData() override {
-        // TODO(bunnei): Find out what this all means. Writing anything non-zero here breaks libnx.
-        Write<u32_le>(0);
-        Write<u32_le>(FENCE_HACK);
-        Write<u32_le>(0);
-        Write(buffer);
+        // TODO(Subv): Figure out what this value means, writing non-zero here will make libnx try
+        // to read an IGBPBuffer object from the parcel.
+        Write<u32_le>(1);
+        WriteObject(buffer);
         Write<u32_le>(0);
     }
 

src/yuzu/debugger/wait_tree.cpp

@@ -5,6 +5,7 @@
 #include "yuzu/debugger/wait_tree.h"
 #include "yuzu/util/util.h"
 
+#include "core/core.h"
 #include "core/hle/kernel/condition_variable.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/mutex.h"
@@ -50,7 +51,7 @@ std::size_t WaitTreeItem::Row() const {
 }
 
 std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList() {
-    const auto& threads = Kernel::GetThreadList();
+    const auto& threads = Core::System::GetInstance().Scheduler().GetThreadList();
     std::vector<std::unique_ptr<WaitTreeThread>> item_list;
     item_list.reserve(threads.size());
     for (std::size_t i = 0; i < threads.size(); ++i) {