1 files changed, 709 insertions, 0 deletions

diff --git a/src/core/hle/service/ro/ro.cpp b/src/core/hle/service/ro/ro.cpp
new file mode 100644
index 000000000..17110d3f1
--- /dev/null
+++ b/src/core/hle/service/ro/ro.cpp
@@ -0,0 +1,709 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <mbedtls/sha256.h>
+
+#include "common/scope_exit.h"
+#include "core/hle/kernel/k_process.h"
+
+#include "core/hle/service/ipc_helpers.h"
+#include "core/hle/service/ro/ro.h"
+#include "core/hle/service/ro/ro_nro_utils.h"
+#include "core/hle/service/ro/ro_results.h"
+#include "core/hle/service/ro/ro_types.h"
+#include "core/hle/service/server_manager.h"
+#include "core/hle/service/service.h"
+
+namespace Service::RO {
+
+namespace {
+
+// Convenience definitions.
+constexpr size_t MaxSessions = 0x3;
+constexpr size_t MaxNrrInfos = 0x40;
+constexpr size_t MaxNroInfos = 0x40;
+
+constexpr u64 InvalidProcessId = 0xffffffffffffffffULL;
+constexpr u64 InvalidContextId = 0xffffffffffffffffULL;
+
+// Types.
+using Sha256Hash = std::array<u8, 32>;
+
+struct NroInfo {
+    u64 base_address;
+    u64 nro_heap_address;
+    u64 nro_heap_size;
+    u64 bss_heap_address;
+    u64 bss_heap_size;
+    u64 code_size;
+    u64 rw_size;
+    ModuleId module_id;
+};
+
+struct NrrInfo {
+    u64 nrr_heap_address;
+    u64 nrr_heap_size;
+
+    // Verification.
+    std::vector<Sha256Hash> hashes;
+};
+
+struct ProcessContext {
+    constexpr ProcessContext() = default;
+
+    void Initialize(Kernel::KProcess* process, u64 process_id) {
+        ASSERT(!m_in_use);
+
+        m_nro_in_use = {};
+        m_nrr_in_use = {};
+        m_nro_infos = {};
+        m_nrr_infos = {};
+
+        m_process = process;
+        m_process_id = process_id;
+        m_in_use = true;
+
+        if (m_process) {
+            m_process->Open();
+        }
+    }
+
+    void Finalize() {
+        ASSERT(m_in_use);
+
+        if (m_process) {
+            m_process->Close();
+        }
+
+        m_nro_in_use = {};
+        m_nrr_in_use = {};
+        m_nro_infos = {};
+        m_nrr_infos = {};
+
+        m_process = nullptr;
+        m_process_id = InvalidProcessId;
+        m_in_use = false;
+    }
+
+    Kernel::KProcess* GetProcess() const {
+        return m_process;
+    }
+
+    u64 GetProcessId() const {
+        return m_process_id;
+    }
+
+    bool IsFree() const {
+        return !m_in_use;
+    }
+
+    u64 GetProgramId(Kernel::KProcess* other_process) const {
+        // Automatically select a handle, allowing for override.
+        if (other_process) {
+            return other_process->GetProgramId();
+        } else if (m_process) {
+            return m_process->GetProgramId();
+        } else {
+            return 0;
+        }
+    }
+
+    Result GetNrrInfoByAddress(NrrInfo** out, u64 nrr_heap_address) {
+        for (size_t i = 0; i < MaxNrrInfos; i++) {
+            if (m_nrr_in_use[i] && m_nrr_infos[i].nrr_heap_address == nrr_heap_address) {
+                if (out != nullptr) {
+                    *out = std::addressof(m_nrr_infos[i]);
+                }
+                R_SUCCEED();
+            }
+        }
+        R_THROW(RO::ResultNotRegistered);
+    }
+
+    Result GetFreeNrrInfo(NrrInfo** out) {
+        for (size_t i = 0; i < MaxNrrInfos; i++) {
+            if (!m_nrr_in_use[i]) {
+                if (out != nullptr) {
+                    *out = std::addressof(m_nrr_infos[i]);
+                }
+                R_SUCCEED();
+            }
+        }
+        R_THROW(RO::ResultTooManyNrr);
+    }
+
+    Result GetNroInfoByAddress(NroInfo** out, u64 nro_address) {
+        for (size_t i = 0; i < MaxNroInfos; i++) {
+            if (m_nro_in_use[i] && m_nro_infos[i].base_address == nro_address) {
+                if (out != nullptr) {
+                    *out = std::addressof(m_nro_infos[i]);
+                }
+                R_SUCCEED();
+            }
+        }
+        R_THROW(RO::ResultNotLoaded);
+    }
+
+    Result GetNroInfoByModuleId(NroInfo** out, const ModuleId* module_id) {
+        for (size_t i = 0; i < MaxNroInfos; i++) {
+            if (m_nro_in_use[i] && std::memcmp(std::addressof(m_nro_infos[i].module_id), module_id,
+                                               sizeof(*module_id)) == 0) {
+                if (out != nullptr) {
+                    *out = std::addressof(m_nro_infos[i]);
+                }
+                R_SUCCEED();
+            }
+        }
+        R_THROW(RO::ResultNotLoaded);
+    }
+
+    Result GetFreeNroInfo(NroInfo** out) {
+        for (size_t i = 0; i < MaxNroInfos; i++) {
+            if (!m_nro_in_use[i]) {
+                if (out != nullptr) {
+                    *out = std::addressof(m_nro_infos[i]);
+                }
+                R_SUCCEED();
+            }
+        }
+        R_THROW(RO::ResultTooManyNro);
+    }
+
+    Result ValidateHasNroHash(u64 base_address, const NroHeader* nro_header) const {
+        // Calculate hash.
+        Sha256Hash hash;
+        {
+            const u64 size = nro_header->GetSize();
+
+            std::vector<u8> nro_data(size);
+            m_process->GetMemory().ReadBlock(base_address, nro_data.data(), size);
+
+            mbedtls_sha256_ret(nro_data.data(), size, hash.data(), 0);
+        }
+
+        for (size_t i = 0; i < MaxNrrInfos; i++) {
+            // Ensure we only check NRRs that are used.
+            if (!m_nrr_in_use[i]) {
+                continue;
+            }
+
+            // Locate the hash within the hash list.
+            const auto hash_it = std::ranges::find(m_nrr_infos[i].hashes, hash);
+            if (hash_it == m_nrr_infos[i].hashes.end()) {
+                continue;
+            }
+
+            // The hash is valid!
+            R_SUCCEED();
+        }
+
+        R_THROW(RO::ResultNotAuthorized);
+    }
+
+    Result ValidateNro(ModuleId* out_module_id, u64* out_rx_size, u64* out_ro_size,
+                       u64* out_rw_size, u64 base_address, u64 expected_nro_size,
+                       u64 expected_bss_size) {
+        // Ensure we have a process to work on.
+        R_UNLESS(m_process != nullptr, RO::ResultInvalidProcess);
+
+        // Read the NRO header.
+        NroHeader header{};
+        m_process->GetMemory().ReadBlock(base_address, std::addressof(header), sizeof(header));
+
+        // Validate header.
+        R_UNLESS(header.IsMagicValid(), RO::ResultInvalidNro);
+
+        // Read sizes from header.
+        const u64 nro_size = header.GetSize();
+        const u64 text_ofs = header.GetTextOffset();
+        const u64 text_size = header.GetTextSize();
+        const u64 ro_ofs = header.GetRoOffset();
+        const u64 ro_size = header.GetRoSize();
+        const u64 rw_ofs = header.GetRwOffset();
+        const u64 rw_size = header.GetRwSize();
+        const u64 bss_size = header.GetBssSize();
+
+        // Validate sizes meet expected.
+        R_UNLESS(nro_size == expected_nro_size, RO::ResultInvalidNro);
+        R_UNLESS(bss_size == expected_bss_size, RO::ResultInvalidNro);
+
+        // Validate all sizes are aligned.
+        R_UNLESS(Common::IsAligned(text_size, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidNro);
+        R_UNLESS(Common::IsAligned(ro_size, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidNro);
+        R_UNLESS(Common::IsAligned(rw_size, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidNro);
+        R_UNLESS(Common::IsAligned(bss_size, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidNro);
+
+        // Validate sections are in order.
+        R_UNLESS(text_ofs <= ro_ofs, RO::ResultInvalidNro);
+        R_UNLESS(ro_ofs <= rw_ofs, RO::ResultInvalidNro);
+
+        // Validate sections are sequential and contiguous.
+        R_UNLESS(text_ofs == 0, RO::ResultInvalidNro);
+        R_UNLESS(text_ofs + text_size == ro_ofs, RO::ResultInvalidNro);
+        R_UNLESS(ro_ofs + ro_size == rw_ofs, RO::ResultInvalidNro);
+        R_UNLESS(rw_ofs + rw_size == nro_size, RO::ResultInvalidNro);
+
+        // Verify NRO hash.
+        R_TRY(this->ValidateHasNroHash(base_address, std::addressof(header)));
+
+        // Check if NRO has already been loaded.
+        const ModuleId* module_id = header.GetModuleId();
+        R_UNLESS(R_FAILED(this->GetNroInfoByModuleId(nullptr, module_id)), RO::ResultAlreadyLoaded);
+
+        // Apply patches to NRO.
+        // LocateAndApplyIpsPatchesToModule(module_id, static_cast<u8*>(mapped_memory), nro_size);
+
+        // Copy to output.
+        *out_module_id = *module_id;
+        *out_rx_size = text_size;
+        *out_ro_size = ro_size;
+        *out_rw_size = rw_size;
+        R_SUCCEED();
+    }
+
+    void SetNrrInfoInUse(const NrrInfo* info, bool in_use) {
+        ASSERT(std::addressof(m_nrr_infos[0]) <= info &&
+               info <= std::addressof(m_nrr_infos[MaxNrrInfos - 1]));
+        const size_t index = info - std::addressof(m_nrr_infos[0]);
+        m_nrr_in_use[index] = in_use;
+    }
+
+    void SetNroInfoInUse(const NroInfo* info, bool in_use) {
+        ASSERT(std::addressof(m_nro_infos[0]) <= info &&
+               info <= std::addressof(m_nro_infos[MaxNroInfos - 1]));
+        const size_t index = info - std::addressof(m_nro_infos[0]);
+        m_nro_in_use[index] = in_use;
+    }
+
+private:
+    std::array<bool, MaxNroInfos> m_nro_in_use{};
+    std::array<bool, MaxNrrInfos> m_nrr_in_use{};
+    std::array<NroInfo, MaxNroInfos> m_nro_infos{};
+    std::array<NrrInfo, MaxNrrInfos> m_nrr_infos{};
+    Kernel::KProcess* m_process{};
+    u64 m_process_id{InvalidProcessId};
+    bool m_in_use{};
+};
+
+Result ValidateAddressAndNonZeroSize(u64 address, u64 size) {
+    R_UNLESS(Common::IsAligned(address, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidAddress);
+    R_UNLESS(size != 0, RO::ResultInvalidSize);
+    R_UNLESS(Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidSize);
+    R_UNLESS(address < address + size, RO::ResultInvalidSize);
+    R_SUCCEED();
+}
+
+Result ValidateAddressAndSize(u64 address, u64 size) {
+    R_UNLESS(Common::IsAligned(address, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidAddress);
+    R_UNLESS(Common::IsAligned(size, Core::Memory::YUZU_PAGESIZE), RO::ResultInvalidSize);
+    R_UNLESS(size == 0 || address < address + size, RO::ResultInvalidSize);
+    R_SUCCEED();
+}
+
+class RoContext {
+public:
+    explicit RoContext() = default;
+
+    Result RegisterProcess(size_t* out_context_id, Kernel::KProcess* process, u64 process_id) {
+        // Validate process id.
+        R_UNLESS(process->GetProcessId() == process_id, RO::ResultInvalidProcess);
+
+        // Check if a process context already exists.
+        R_UNLESS(this->GetContextByProcessId(process_id) == nullptr, RO::ResultInvalidSession);
+
+        // Allocate a context to manage the process handle.
+        *out_context_id = this->AllocateContext(process, process_id);
+
+        R_SUCCEED();
+    }
+
+    Result ValidateProcess(size_t context_id, u64 process_id) {
+        const ProcessContext* ctx = this->GetContextById(context_id);
+        R_UNLESS(ctx != nullptr, RO::ResultInvalidProcess);
+        R_UNLESS(ctx->GetProcessId() == process_id, RO::ResultInvalidProcess);
+        R_SUCCEED();
+    }
+
+    void UnregisterProcess(size_t context_id) {
+        this->FreeContext(context_id);
+    }
+
+    Result RegisterModuleInfo(size_t context_id, u64 nrr_address, u64 nrr_size, NrrKind nrr_kind,
+                              bool enforce_nrr_kind) {
+        // Get context.
+        ProcessContext* context = this->GetContextById(context_id);
+        ASSERT(context != nullptr);
+
+        // Validate address/size.
+        R_TRY(ValidateAddressAndNonZeroSize(nrr_address, nrr_size));
+
+        // Check we have space for a new NRR.
+        NrrInfo* nrr_info = nullptr;
+        R_TRY(context->GetFreeNrrInfo(std::addressof(nrr_info)));
+
+        // Ensure we have a valid process to read from.
+        Kernel::KProcess* process = context->GetProcess();
+        R_UNLESS(process != nullptr, RO::ResultInvalidProcess);
+
+        // Read NRR.
+        NrrHeader header{};
+        process->GetMemory().ReadBlock(nrr_address, std::addressof(header), sizeof(header));
+
+        // Set NRR info.
+        context->SetNrrInfoInUse(nrr_info, true);
+        nrr_info->nrr_heap_address = nrr_address;
+        nrr_info->nrr_heap_size = nrr_size;
+
+        // Read NRR hash list.
+        nrr_info->hashes.resize(header.GetNumHashes());
+        process->GetMemory().ReadBlock(nrr_address + header.GetHashesOffset(),
+                                       nrr_info->hashes.data(),
+                                       sizeof(Sha256Hash) * header.GetNumHashes());
+
+        R_SUCCEED();
+    }
+
+    Result UnregisterModuleInfo(size_t context_id, u64 nrr_address) {
+        // Get context.
+        ProcessContext* context = this->GetContextById(context_id);
+        ASSERT(context != nullptr);
+
+        // Validate address.
+        R_UNLESS(Common::IsAligned(nrr_address, Core::Memory::YUZU_PAGESIZE),
+                 RO::ResultInvalidAddress);
+
+        // Check the NRR is loaded.
+        NrrInfo* nrr_info = nullptr;
+        R_TRY(context->GetNrrInfoByAddress(std::addressof(nrr_info), nrr_address));
+
+        // Nintendo does this unconditionally, whether or not the actual unmap succeeds.
+        context->SetNrrInfoInUse(nrr_info, false);
+        *nrr_info = {};
+
+        R_SUCCEED();
+    }
+
+    Result MapManualLoadModuleMemory(u64* out_address, size_t context_id, u64 nro_address,
+                                     u64 nro_size, u64 bss_address, u64 bss_size) {
+        // Get context.
+        ProcessContext* context = this->GetContextById(context_id);
+        ASSERT(context != nullptr);
+
+        // Validate address/size.
+        R_TRY(ValidateAddressAndNonZeroSize(nro_address, nro_size));
+        R_TRY(ValidateAddressAndSize(bss_address, bss_size));
+
+        const u64 total_size = nro_size + bss_size;
+        R_UNLESS(total_size >= nro_size, RO::ResultInvalidSize);
+        R_UNLESS(total_size >= bss_size, RO::ResultInvalidSize);
+
+        // Check we have space for a new NRO.
+        NroInfo* nro_info = nullptr;
+        R_TRY(context->GetFreeNroInfo(std::addressof(nro_info)));
+        nro_info->nro_heap_address = nro_address;
+        nro_info->nro_heap_size = nro_size;
+        nro_info->bss_heap_address = bss_address;
+        nro_info->bss_heap_size = bss_size;
+
+        // Map the NRO.
+        R_TRY(MapNro(std::addressof(nro_info->base_address), context->GetProcess(), nro_address,
+                     nro_size, bss_address, bss_size, generate_random));
+        ON_RESULT_FAILURE {
+            UnmapNro(context->GetProcess(), nro_info->base_address, nro_address, nro_size,
+                     bss_address, bss_size);
+        };
+
+        // Validate the NRO (parsing region extents).
+        u64 rx_size = 0, ro_size = 0, rw_size = 0;
+        R_TRY(context->ValidateNro(std::addressof(nro_info->module_id), std::addressof(rx_size),
+                                   std::addressof(ro_size), std::addressof(rw_size),
+                                   nro_info->base_address, nro_size, bss_size));
+
+        // Set NRO perms.
+        R_TRY(SetNroPerms(context->GetProcess(), nro_info->base_address, rx_size, ro_size,
+                          rw_size + bss_size));
+
+        context->SetNroInfoInUse(nro_info, true);
+        nro_info->code_size = rx_size + ro_size;
+        nro_info->rw_size = rw_size;
+        *out_address = nro_info->base_address;
+        R_SUCCEED();
+    }
+
+    Result UnmapManualLoadModuleMemory(size_t context_id, u64 nro_address) {
+        // Get context.
+        ProcessContext* context = this->GetContextById(context_id);
+        ASSERT(context != nullptr);
+
+        // Validate address.
+        R_UNLESS(Common::IsAligned(nro_address, Core::Memory::YUZU_PAGESIZE),
+                 RO::ResultInvalidAddress);
+
+        // Check the NRO is loaded.
+        NroInfo* nro_info = nullptr;
+        R_TRY(context->GetNroInfoByAddress(std::addressof(nro_info), nro_address));
+
+        // Unmap.
+        const NroInfo nro_backup = *nro_info;
+        {
+            // Nintendo does this unconditionally, whether or not the actual unmap succeeds.
+            context->SetNroInfoInUse(nro_info, false);
+            std::memset(nro_info, 0, sizeof(*nro_info));
+        }
+        R_RETURN(UnmapNro(context->GetProcess(), nro_backup.base_address,
+                          nro_backup.nro_heap_address, nro_backup.code_size + nro_backup.rw_size,
+                          nro_backup.bss_heap_address, nro_backup.bss_heap_size));
+    }
+
+private:
+    std::array<ProcessContext, MaxSessions> process_contexts;
+    std::mt19937_64 generate_random;
+
+    // Context Helpers.
+    ProcessContext* GetContextById(size_t context_id) {
+        if (context_id == InvalidContextId) {
+            return nullptr;
+        }
+
+        ASSERT(context_id < process_contexts.size());
+        return std::addressof(process_contexts[context_id]);
+    }
+
+    ProcessContext* GetContextByProcessId(u64 process_id) {
+        for (size_t i = 0; i < MaxSessions; i++) {
+            if (process_contexts[i].GetProcessId() == process_id) {
+                return std::addressof(process_contexts[i]);
+            }
+        }
+        return nullptr;
+    }
+
+    size_t AllocateContext(Kernel::KProcess* process, u64 process_id) {
+        // Find a free process context.
+        for (size_t i = 0; i < MaxSessions; i++) {
+            ProcessContext* context = std::addressof(process_contexts[i]);
+
+            if (context->IsFree()) {
+                context->Initialize(process, process_id);
+                return i;
+            }
+        }
+
+        // Failure to find a free context is actually an abort condition.
+        UNREACHABLE();
+    }
+
+    void FreeContext(size_t context_id) {
+        if (ProcessContext* context = GetContextById(context_id); context != nullptr) {
+            context->Finalize();
+        }
+    }
+};
+
+class RoInterface {
+public:
+    explicit RoInterface(std::shared_ptr<RoContext> ro, NrrKind nrr_kind)
+        : m_ro(ro), m_context_id(InvalidContextId), m_nrr_kind(nrr_kind) {}
+    ~RoInterface() {
+        m_ro->UnregisterProcess(m_context_id);
+    }
+
+    Result MapManualLoadModuleMemory(u64* out_load_address, u64 client_pid, u64 nro_address,
+                                     u64 nro_size, u64 bss_address, u64 bss_size) {
+        R_TRY(m_ro->ValidateProcess(m_context_id, client_pid));
+        R_RETURN(m_ro->MapManualLoadModuleMemory(out_load_address, m_context_id, nro_address,
+                                                 nro_size, bss_address, bss_size));
+    }
+
+    Result UnmapManualLoadModuleMemory(u64 client_pid, u64 nro_address) {
+        R_TRY(m_ro->ValidateProcess(m_context_id, client_pid));
+        R_RETURN(m_ro->UnmapManualLoadModuleMemory(m_context_id, nro_address));
+    }
+
+    Result RegisterModuleInfo(u64 client_pid, u64 nrr_address, u64 nrr_size) {
+        R_TRY(m_ro->ValidateProcess(m_context_id, client_pid));
+        R_RETURN(
+            m_ro->RegisterModuleInfo(m_context_id, nrr_address, nrr_size, NrrKind::User, true));
+    }
+
+    Result UnregisterModuleInfo(u64 client_pid, u64 nrr_address) {
+        R_TRY(m_ro->ValidateProcess(m_context_id, client_pid));
+        R_RETURN(m_ro->UnregisterModuleInfo(m_context_id, nrr_address));
+    }
+
+    Result RegisterProcessHandle(u64 client_pid, Kernel::KProcess* process) {
+        // Register the process.
+        R_RETURN(m_ro->RegisterProcess(std::addressof(m_context_id), process, client_pid));
+    }
+
+    Result RegisterProcessModuleInfo(u64 client_pid, u64 nrr_address, u64 nrr_size,
+                                     Kernel::KProcess* process) {
+        // Validate the process.
+        R_TRY(m_ro->ValidateProcess(m_context_id, client_pid));
+
+        // Register the module.
+        R_RETURN(m_ro->RegisterModuleInfo(m_context_id, nrr_address, nrr_size, m_nrr_kind,
+                                          m_nrr_kind == NrrKind::JitPlugin));
+    }
+
+private:
+    std::shared_ptr<RoContext> m_ro{};
+    size_t m_context_id{};
+    NrrKind m_nrr_kind{};
+};
+
+class IRoInterface : public ServiceFramework<IRoInterface> {
+public:
+    explicit IRoInterface(Core::System& system_, const char* name_, std::shared_ptr<RoContext> ro,
+                          NrrKind nrr_kind)
+        : ServiceFramework{system_, name_}, interface {
+        ro, nrr_kind
+    } {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IRoInterface::MapManualLoadModuleMemory, "MapManualLoadModuleMemory"},
+            {1, &IRoInterface::UnmapManualLoadModuleMemory, "UnmapManualLoadModuleMemory"},
+            {2, &IRoInterface::RegisterModuleInfo, "RegisterModuleInfo"},
+            {3, &IRoInterface::UnregisterModuleInfo, "UnregisterModuleInfo"},
+            {4, &IRoInterface::RegisterProcessHandle, "RegisterProcessHandle"},
+            {10, &IRoInterface::RegisterProcessModuleInfo, "RegisterProcessModuleInfo"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void MapManualLoadModuleMemory(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDR, "(called)");
+
+        struct InputParameters {
+            u64 client_pid;
+            u64 nro_address;
+            u64 nro_size;
+            u64 bss_address;
+            u64 bss_size;
+        };
+
+        IPC::RequestParser rp{ctx};
+        auto params = rp.PopRaw<InputParameters>();
+
+        u64 load_address = 0;
+        auto result = interface.MapManualLoadModuleMemory(&load_address, ctx.GetPID(),
+                                                          params.nro_address, params.nro_size,
+                                                          params.bss_address, params.bss_size);
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(result);
+        rb.Push(load_address);
+    }
+
+    void UnmapManualLoadModuleMemory(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDR, "(called)");
+
+        struct InputParameters {
+            u64 client_pid;
+            u64 nro_address;
+        };
+
+        IPC::RequestParser rp{ctx};
+        auto params = rp.PopRaw<InputParameters>();
+        auto result = interface.UnmapManualLoadModuleMemory(ctx.GetPID(), params.nro_address);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+    }
+
+    void RegisterModuleInfo(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDR, "(called)");
+
+        struct InputParameters {
+            u64 client_pid;
+            u64 nrr_address;
+            u64 nrr_size;
+        };
+
+        IPC::RequestParser rp{ctx};
+        auto params = rp.PopRaw<InputParameters>();
+        auto result =
+            interface.RegisterModuleInfo(ctx.GetPID(), params.nrr_address, params.nrr_size);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+    }
+
+    void UnregisterModuleInfo(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDR, "(called)");
+
+        struct InputParameters {
+            u64 client_pid;
+            u64 nrr_address;
+        };
+
+        IPC::RequestParser rp{ctx};
+        auto params = rp.PopRaw<InputParameters>();
+        auto result = interface.UnregisterModuleInfo(ctx.GetPID(), params.nrr_address);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+    }
+
+    void RegisterProcessHandle(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDR, "(called)");
+
+        auto process_h = ctx.GetClientHandleTable().GetObject(ctx.GetCopyHandle(0));
+        auto client_pid = ctx.GetPID();
+        auto result = interface.RegisterProcessHandle(client_pid,
+                                                      process_h->DynamicCast<Kernel::KProcess*>());
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+    }
+
+    void RegisterProcessModuleInfo(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LDR, "(called)");
+
+        struct InputParameters {
+            u64 client_pid;
+            u64 nrr_address;
+            u64 nrr_size;
+        };
+
+        IPC::RequestParser rp{ctx};
+        auto params = rp.PopRaw<InputParameters>();
+        auto process_h = ctx.GetClientHandleTable().GetObject(ctx.GetCopyHandle(0));
+
+        auto client_pid = ctx.GetPID();
+        auto result =
+            interface.RegisterProcessModuleInfo(client_pid, params.nrr_address, params.nrr_size,
+                                                process_h->DynamicCast<Kernel::KProcess*>());
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+    }
+
+    RoInterface interface;
+};
+
+} // namespace
+
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    auto ro = std::make_shared<RoContext>();
+
+    const auto RoInterfaceFactoryForUser = [&, ro] {
+        return std::make_shared<IRoInterface>(system, "ldr:ro", ro, NrrKind::User);
+    };
+
+    const auto RoInterfaceFactoryForJitPlugin = [&, ro] {
+        return std::make_shared<IRoInterface>(system, "ro:1", ro, NrrKind::JitPlugin);
+    };
+
+    server_manager->RegisterNamedService("ldr:ro", std::move(RoInterfaceFactoryForUser));
+    server_manager->RegisterNamedService("ro:1", std::move(RoInterfaceFactoryForJitPlugin));
+
+    ServerManager::RunServer(std::move(server_manager));
+}
+
+} // namespace Service::RO