From 7ba4a8f4a305a8f5136cd745b73c30becdf7c975 Mon Sep 17 00:00:00 2001 From: Liam Date: Fri, 8 Dec 2023 21:10:42 -0500 Subject: [PATCH] ro: add separate ro service --- src/core/CMakeLists.txt | 6 + src/core/hle/service/ldr/ldr.cpp | 634 -------------------- src/core/hle/service/ro/ro.cpp | 709 +++++++++++++++++++++++ src/core/hle/service/ro/ro.h | 14 + src/core/hle/service/ro/ro_nro_utils.cpp | 185 ++++++ src/core/hle/service/ro/ro_nro_utils.h | 26 + src/core/hle/service/ro/ro_results.h | 24 + src/core/hle/service/ro/ro_types.h | 181 ++++++ src/core/hle/service/service.cpp | 2 + 9 files changed, 1147 insertions(+), 634 deletions(-) create mode 100644 src/core/hle/service/ro/ro.cpp create mode 100644 src/core/hle/service/ro/ro.h create mode 100644 src/core/hle/service/ro/ro_nro_utils.cpp create mode 100644 src/core/hle/service/ro/ro_nro_utils.h create mode 100644 src/core/hle/service/ro/ro_results.h create mode 100644 src/core/hle/service/ro/ro_types.h diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index b483fd975..12e0534c4 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -766,6 +766,12 @@ add_library(core STATIC hle/service/kernel_helpers.h hle/service/mutex.cpp hle/service/mutex.h + hle/service/ro/ro_nro_utils.cpp + hle/service/ro/ro_nro_utils.h + hle/service/ro/ro_results.h + hle/service/ro/ro_types.h + hle/service/ro/ro.cpp + hle/service/ro/ro.h hle/service/server_manager.cpp hle/service/server_manager.h hle/service/service.cpp diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp index 97b6a9385..ba58b3a09 100644 --- a/src/core/hle/service/ldr/ldr.cpp +++ b/src/core/hle/service/ldr/ldr.cpp @@ -1,117 +1,12 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include -#include -#include - -#include "common/alignment.h" -#include "common/hex_util.h" -#include "common/scope_exit.h" -#include "core/core.h" -#include "core/hle/kernel/k_page_table.h" -#include "core/hle/kernel/svc_results.h" -#include "core/hle/kernel/svc_types.h" -#include "core/hle/service/ipc_helpers.h" #include "core/hle/service/ldr/ldr.h" #include "core/hle/service/server_manager.h" #include "core/hle/service/service.h" -#include "core/loader/nro.h" -#include "core/memory.h" namespace Service::LDR { -constexpr Result ERROR_INSUFFICIENT_ADDRESS_SPACE{ErrorModule::RO, 2}; - -[[maybe_unused]] constexpr Result ERROR_INVALID_MEMORY_STATE{ErrorModule::Loader, 51}; -constexpr Result ERROR_INVALID_NRO{ErrorModule::Loader, 52}; -constexpr Result ERROR_INVALID_NRR{ErrorModule::Loader, 53}; -constexpr Result ERROR_MISSING_NRR_HASH{ErrorModule::Loader, 54}; -constexpr Result ERROR_MAXIMUM_NRO{ErrorModule::Loader, 55}; -constexpr Result ERROR_MAXIMUM_NRR{ErrorModule::Loader, 56}; -constexpr Result ERROR_ALREADY_LOADED{ErrorModule::Loader, 57}; -constexpr Result ERROR_INVALID_ALIGNMENT{ErrorModule::Loader, 81}; -constexpr Result ERROR_INVALID_SIZE{ErrorModule::Loader, 82}; -constexpr Result ERROR_INVALID_NRO_ADDRESS{ErrorModule::Loader, 84}; -[[maybe_unused]] constexpr Result ERROR_INVALID_NRR_ADDRESS{ErrorModule::Loader, 85}; -constexpr Result ERROR_NOT_INITIALIZED{ErrorModule::Loader, 87}; - -constexpr std::size_t MAXIMUM_LOADED_RO{0x40}; -constexpr std::size_t MAXIMUM_MAP_RETRIES{0x200}; - -constexpr std::size_t TEXT_INDEX{0}; -constexpr std::size_t RO_INDEX{1}; -constexpr std::size_t DATA_INDEX{2}; - -struct NRRCertification { - u64_le application_id_mask; - u64_le application_id_pattern; - INSERT_PADDING_BYTES(0x10); - std::array public_key; // Also known as modulus - std::array signature; -}; -static_assert(sizeof(NRRCertification) == 0x220, "NRRCertification has invalid size."); - -struct NRRHeader { - u32_le magic; - u32_le certification_signature_key_generation; // 9.0.0+ - INSERT_PADDING_WORDS(2); - NRRCertification certification; - std::array signature; - u64_le application_id; - u32_le size; - u8 nrr_kind; // 7.0.0+ - INSERT_PADDING_BYTES(3); - u32_le hash_offset; - u32_le hash_count; - INSERT_PADDING_WORDS(2); -}; -static_assert(sizeof(NRRHeader) == 0x350, "NRRHeader has invalid size."); - -struct SegmentHeader { - u32_le memory_offset; - u32_le memory_size; -}; -static_assert(sizeof(SegmentHeader) == 0x8, "SegmentHeader has invalid size."); - -struct NROHeader { - // Switchbrew calls this "Start" (0x10) - INSERT_PADDING_WORDS(1); - u32_le mod_offset; - INSERT_PADDING_WORDS(2); - - // Switchbrew calls this "Header" (0x70) - u32_le magic; - u32_le version; - u32_le nro_size; - u32_le flags; - // .text, .ro, .data - std::array segment_headers; - u32_le bss_size; - INSERT_PADDING_WORDS(1); - std::array build_id; - u32_le dso_handle_offset; - INSERT_PADDING_WORDS(1); - // .apiInfo, .dynstr, .dynsym - std::array segment_headers_2; -}; -static_assert(sizeof(NROHeader) == 0x80, "NROHeader has invalid size."); - -using SHA256Hash = std::array; - -struct NROInfo { - SHA256Hash hash{}; - VAddr nro_address{}; - std::size_t nro_size{}; - VAddr bss_address{}; - std::size_t bss_size{}; - std::size_t text_size{}; - std::size_t ro_size{}; - std::size_t data_size{}; - VAddr src_addr{}; -}; -static_assert(sizeof(NROInfo) == 0x60, "NROInfo has invalid size."); - class DebugMonitor final : public ServiceFramework { public: explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "ldr:dmnt"} { @@ -158,541 +53,12 @@ public: } }; -class RelocatableObject final : public ServiceFramework { -public: - explicit RelocatableObject(Core::System& system_) : ServiceFramework{system_, "ldr:ro"} { - // clang-format off - static const FunctionInfo functions[] = { - {0, &RelocatableObject::LoadModule, "LoadModule"}, - {1, &RelocatableObject::UnloadModule, "UnloadModule"}, - {2, &RelocatableObject::RegisterModuleInfo, "RegisterModuleInfo"}, - {3, &RelocatableObject::UnregisterModuleInfo, "UnregisterModuleInfo"}, - {4, &RelocatableObject::Initialize, "Initialize"}, - {10, nullptr, "RegisterModuleInfo2"}, - }; - // clang-format on - - RegisterHandlers(functions); - } - - void RegisterModuleInfo(HLERequestContext& ctx) { - struct Parameters { - u64_le process_id; - u64_le nrr_address; - u64_le nrr_size; - }; - - IPC::RequestParser rp{ctx}; - const auto [process_id, nrr_address, nrr_size] = rp.PopRaw(); - - LOG_DEBUG(Service_LDR, - "called with process_id={:016X}, nrr_address={:016X}, nrr_size={:016X}", - process_id, nrr_address, nrr_size); - - if (!initialized) { - LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_NOT_INITIALIZED); - return; - } - - if (nrr.size() >= MAXIMUM_LOADED_RO) { - LOG_ERROR(Service_LDR, "Loading new NRR would exceed the maximum number of loaded NRRs " - "(0x40)! Failing..."); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_MAXIMUM_NRR); - return; - } - - // NRR Address does not fall on 0x1000 byte boundary - if (!Common::Is4KBAligned(nrr_address)) { - LOG_ERROR(Service_LDR, "NRR Address has invalid alignment (actual {:016X})!", - nrr_address); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_ALIGNMENT); - return; - } - - // NRR Size is zero or causes overflow - if (nrr_address + nrr_size <= nrr_address || nrr_size == 0 || - !Common::Is4KBAligned(nrr_size)) { - LOG_ERROR(Service_LDR, "NRR Size is invalid! (nrr_address={:016X}, nrr_size={:016X})", - nrr_address, nrr_size); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_SIZE); - return; - } - - // Read NRR data from memory - std::vector nrr_data(nrr_size); - system.ApplicationMemory().ReadBlock(nrr_address, nrr_data.data(), nrr_size); - NRRHeader header; - std::memcpy(&header, nrr_data.data(), sizeof(NRRHeader)); - - if (header.magic != Common::MakeMagic('N', 'R', 'R', '0')) { - LOG_ERROR(Service_LDR, "NRR did not have magic 'NRR0' (actual {:08X})!", header.magic); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_NRR); - return; - } - - if (header.size != nrr_size) { - LOG_ERROR(Service_LDR, - "NRR header reported size did not match LoadNrr parameter size! " - "(header_size={:016X}, loadnrr_size={:016X})", - header.size, nrr_size); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_SIZE); - return; - } - - if (system.GetApplicationProcessProgramID() != header.application_id) { - LOG_ERROR(Service_LDR, - "Attempting to load NRR with title ID other than current process. (actual " - "{:016X})!", - header.application_id); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_NRR); - return; - } - - std::vector hashes; - - // Copy all hashes in the NRR (specified by hash count/hash offset) into vector. - for (std::size_t i = header.hash_offset; - i < (header.hash_offset + (header.hash_count * sizeof(SHA256Hash))); i += 8) { - SHA256Hash hash; - std::memcpy(hash.data(), nrr_data.data() + i, sizeof(SHA256Hash)); - hashes.emplace_back(hash); - } - - nrr.insert_or_assign(nrr_address, std::move(hashes)); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - } - - void UnregisterModuleInfo(HLERequestContext& ctx) { - IPC::RequestParser rp{ctx}; - const auto pid = rp.Pop(); - const auto nrr_address = rp.Pop(); - - LOG_DEBUG(Service_LDR, "called with pid={}, nrr_address={:016X}", pid, nrr_address); - - nrr.erase(nrr_address); - - IPC::ResponseBuilder rb{ctx, 2}; - - rb.Push(ResultSuccess); - } - - bool ValidateRegionForMap(Kernel::KProcessPageTable& page_table, VAddr start, - std::size_t size) const { - const std::size_t padding_size{page_table.GetNumGuardPages() * Kernel::PageSize}; - - Kernel::KMemoryInfo start_info; - Kernel::Svc::PageInfo page_info; - R_ASSERT( - page_table.QueryInfo(std::addressof(start_info), std::addressof(page_info), start - 1)); - - if (start_info.GetState() != Kernel::KMemoryState::Free) { - return {}; - } - - if (start_info.GetAddress() > (start - padding_size)) { - return {}; - } - - Kernel::KMemoryInfo end_info; - R_ASSERT(page_table.QueryInfo(std::addressof(end_info), std::addressof(page_info), - start + size)); - - if (end_info.GetState() != Kernel::KMemoryState::Free) { - return {}; - } - - return (start + size + padding_size) <= (end_info.GetAddress() + end_info.GetSize()); - } - - Result GetAvailableMapRegion(Kernel::KProcessPageTable& page_table, u64 size, VAddr& out_addr) { - size = Common::AlignUp(size, Kernel::PageSize); - size += page_table.GetNumGuardPages() * Kernel::PageSize * 4; - - const auto is_region_available = [&](VAddr addr) { - const auto end_addr = addr + size; - while (addr < end_addr) { - if (system.ApplicationMemory().IsValidVirtualAddress(addr)) { - return false; - } - - if (!page_table.Contains(out_addr, size)) { - return false; - } - - if (page_table.IsInHeapRegion(out_addr, size)) { - return false; - } - - if (page_table.IsInAliasRegion(out_addr, size)) { - return false; - } - - addr += Kernel::PageSize; - } - return true; - }; - - bool succeeded = false; - const auto map_region_end = - GetInteger(page_table.GetAliasCodeRegionStart()) + page_table.GetAliasCodeRegionSize(); - while (current_map_addr < map_region_end) { - if (is_region_available(current_map_addr)) { - succeeded = true; - break; - } - current_map_addr += 0x100000; - } - - if (!succeeded) { - ASSERT_MSG(false, "Out of address space!"); - return Kernel::ResultOutOfMemory; - } - - out_addr = current_map_addr; - current_map_addr += size; - - return ResultSuccess; - } - - Result MapProcessCodeMemory(VAddr* out_map_location, Kernel::KProcess* process, VAddr base_addr, - u64 size) { - auto& page_table{process->GetPageTable()}; - VAddr addr{}; - - for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) { - R_TRY(GetAvailableMapRegion(page_table, size, addr)); - - const Result result{page_table.MapCodeMemory(addr, base_addr, size)}; - if (result == Kernel::ResultInvalidCurrentMemory) { - continue; - } - - R_TRY(result); - - if (ValidateRegionForMap(page_table, addr, size)) { - *out_map_location = addr; - return ResultSuccess; - } - } - - return ERROR_INSUFFICIENT_ADDRESS_SPACE; - } - - Result MapNro(VAddr* out_map_location, Kernel::KProcess* process, VAddr nro_addr, - std::size_t nro_size, VAddr bss_addr, std::size_t bss_size, std::size_t size) { - for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) { - auto& page_table{process->GetPageTable()}; - VAddr addr{}; - - R_TRY(MapProcessCodeMemory(&addr, process, nro_addr, nro_size)); - - if (bss_size) { - auto block_guard = detail::ScopeExit([&] { - page_table.UnmapCodeMemory(addr + nro_size, bss_addr, bss_size); - page_table.UnmapCodeMemory(addr, nro_addr, nro_size); - }); - - const Result result{page_table.MapCodeMemory(addr + nro_size, bss_addr, bss_size)}; - - if (result == Kernel::ResultInvalidCurrentMemory) { - continue; - } - - if (result.IsError()) { - return result; - } - - block_guard.Cancel(); - } - - if (ValidateRegionForMap(page_table, addr, size)) { - *out_map_location = addr; - return ResultSuccess; - } - } - - return ERROR_INSUFFICIENT_ADDRESS_SPACE; - } - - Result LoadNro(Kernel::KProcess* process, const NROHeader& nro_header, VAddr nro_addr, - VAddr start) const { - const VAddr text_start{start + nro_header.segment_headers[TEXT_INDEX].memory_offset}; - const VAddr ro_start{start + nro_header.segment_headers[RO_INDEX].memory_offset}; - const VAddr data_start{start + nro_header.segment_headers[DATA_INDEX].memory_offset}; - const VAddr bss_start{data_start + nro_header.segment_headers[DATA_INDEX].memory_size}; - const VAddr bss_end_addr{ - Common::AlignUp(bss_start + nro_header.bss_size, Kernel::PageSize)}; - - const auto CopyCode = [this](VAddr src_addr, VAddr dst_addr, u64 size) { - system.ApplicationMemory().CopyBlock(dst_addr, src_addr, size); - }; - CopyCode(nro_addr + nro_header.segment_headers[TEXT_INDEX].memory_offset, text_start, - nro_header.segment_headers[TEXT_INDEX].memory_size); - CopyCode(nro_addr + nro_header.segment_headers[RO_INDEX].memory_offset, ro_start, - nro_header.segment_headers[RO_INDEX].memory_size); - CopyCode(nro_addr + nro_header.segment_headers[DATA_INDEX].memory_offset, data_start, - nro_header.segment_headers[DATA_INDEX].memory_size); - - R_TRY(process->GetPageTable().SetProcessMemoryPermission( - text_start, ro_start - text_start, Kernel::Svc::MemoryPermission::ReadExecute)); - R_TRY(process->GetPageTable().SetProcessMemoryPermission( - ro_start, data_start - ro_start, Kernel::Svc::MemoryPermission::Read)); - - return process->GetPageTable().SetProcessMemoryPermission( - data_start, bss_end_addr - data_start, Kernel::Svc::MemoryPermission::ReadWrite); - } - - void LoadModule(HLERequestContext& ctx) { - struct Parameters { - u64_le process_id; - u64_le image_address; - u64_le image_size; - u64_le bss_address; - u64_le bss_size; - }; - - IPC::RequestParser rp{ctx}; - const auto [process_id, nro_address, nro_size, bss_address, bss_size] = - rp.PopRaw(); - - LOG_DEBUG(Service_LDR, - "called with pid={:016X}, nro_addr={:016X}, nro_size={:016X}, bss_addr={:016X}, " - "bss_size={:016X}", - process_id, nro_address, nro_size, bss_address, bss_size); - - if (!initialized) { - LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_NOT_INITIALIZED); - return; - } - - if (nro.size() >= MAXIMUM_LOADED_RO) { - LOG_ERROR(Service_LDR, "Loading new NRO would exceed the maximum number of loaded NROs " - "(0x40)! Failing..."); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_MAXIMUM_NRO); - return; - } - - // NRO Address does not fall on 0x1000 byte boundary - if (!Common::Is4KBAligned(nro_address)) { - LOG_ERROR(Service_LDR, "NRO Address has invalid alignment (actual {:016X})!", - nro_address); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_ALIGNMENT); - return; - } - - // NRO Size or BSS Size is zero or causes overflow - const auto nro_size_valid = - nro_size != 0 && nro_address + nro_size > nro_address && Common::Is4KBAligned(nro_size); - const auto bss_size_valid = nro_size + bss_size >= nro_size && - (bss_size == 0 || bss_address + bss_size > bss_address); - - if (!nro_size_valid || !bss_size_valid) { - LOG_ERROR(Service_LDR, - "NRO Size or BSS Size is invalid! (nro_address={:016X}, nro_size={:016X}, " - "bss_address={:016X}, bss_size={:016X})", - nro_address, nro_size, bss_address, bss_size); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_SIZE); - return; - } - - // Read NRO data from memory - std::vector nro_data(nro_size); - system.ApplicationMemory().ReadBlock(nro_address, nro_data.data(), nro_size); - - SHA256Hash hash{}; - mbedtls_sha256_ret(nro_data.data(), nro_data.size(), hash.data(), 0); - - // NRO Hash is already loaded - if (std::any_of(nro.begin(), nro.end(), [&hash](const std::pair& info) { - return info.second.hash == hash; - })) { - LOG_ERROR(Service_LDR, "NRO is already loaded!"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_ALREADY_LOADED); - return; - } - - // NRO Hash is not in any loaded NRR - if (!IsValidNROHash(hash)) { - LOG_ERROR(Service_LDR, - "NRO hash is not present in any currently loaded NRRs (hash={})!", - Common::HexToString(hash)); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_MISSING_NRR_HASH); - return; - } - - // Load and validate the NRO header - NROHeader header{}; - std::memcpy(&header, nro_data.data(), sizeof(NROHeader)); - if (!IsValidNRO(header, nro_size, bss_size)) { - LOG_ERROR(Service_LDR, "NRO was invalid!"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_NRO); - return; - } - - // Map memory for the NRO - VAddr map_location{}; - const auto map_result{MapNro(&map_location, system.ApplicationProcess(), nro_address, - nro_size, bss_address, bss_size, nro_size + bss_size)}; - if (map_result != ResultSuccess) { - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(map_result); - } - - // Load the NRO into the mapped memory - if (const auto result{ - LoadNro(system.ApplicationProcess(), header, nro_address, map_location)}; - result.IsError()) { - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result); - } - - // Track the loaded NRO - nro.insert_or_assign(map_location, - NROInfo{hash, map_location, nro_size, bss_address, bss_size, - header.segment_headers[TEXT_INDEX].memory_size, - header.segment_headers[RO_INDEX].memory_size, - header.segment_headers[DATA_INDEX].memory_size, nro_address}); - - IPC::ResponseBuilder rb{ctx, 4}; - rb.Push(ResultSuccess); - rb.Push(map_location); - } - - Result UnmapNro(const NROInfo& info) { - // Each region must be unmapped separately to validate memory state - auto& page_table{system.ApplicationProcess()->GetPageTable()}; - - if (info.bss_size != 0) { - R_TRY(page_table.UnmapCodeMemory(info.nro_address + info.text_size + info.ro_size + - info.data_size, - info.bss_address, info.bss_size)); - } - - R_TRY(page_table.UnmapCodeMemory(info.nro_address + info.text_size + info.ro_size, - info.src_addr + info.text_size + info.ro_size, - info.data_size)); - R_TRY(page_table.UnmapCodeMemory(info.nro_address + info.text_size, - info.src_addr + info.text_size, info.ro_size)); - R_TRY(page_table.UnmapCodeMemory(info.nro_address, info.src_addr, info.text_size)); - return ResultSuccess; - } - - void UnloadModule(HLERequestContext& ctx) { - if (!initialized) { - LOG_ERROR(Service_LDR, "LDR:RO not initialized before use!"); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_NOT_INITIALIZED); - return; - } - - struct Parameters { - u64_le process_id; - u64_le nro_address; - }; - - IPC::RequestParser rp{ctx}; - const auto [process_id, nro_address] = rp.PopRaw(); - LOG_DEBUG(Service_LDR, "called with process_id={:016X}, nro_address=0x{:016X}", process_id, - nro_address); - - if (!Common::Is4KBAligned(nro_address)) { - LOG_ERROR(Service_LDR, "NRO address has invalid alignment (nro_address=0x{:016X})", - nro_address); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_ALIGNMENT); - return; - } - - const auto iter = nro.find(nro_address); - if (iter == nro.end()) { - LOG_ERROR(Service_LDR, - "The NRO attempting to be unmapped was not mapped or has an invalid address " - "(nro_address=0x{:016X})!", - nro_address); - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ERROR_INVALID_NRO_ADDRESS); - return; - } - - const auto result{UnmapNro(iter->second)}; - - nro.erase(iter); - - IPC::ResponseBuilder rb{ctx, 2}; - - rb.Push(result); - } - - void Initialize(HLERequestContext& ctx) { - LOG_WARNING(Service_LDR, "(STUBBED) called"); - - initialized = true; - current_map_addr = - GetInteger(system.ApplicationProcess()->GetPageTable().GetAliasCodeRegionStart()); - - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(ResultSuccess); - } - -private: - bool initialized{}; - - std::map nro; - std::map> nrr; - VAddr current_map_addr{}; - - bool IsValidNROHash(const SHA256Hash& hash) const { - return std::any_of(nrr.begin(), nrr.end(), [&hash](const auto& p) { - return std::find(p.second.begin(), p.second.end(), hash) != p.second.end(); - }); - } - - static bool IsValidNRO(const NROHeader& header, u64 nro_size, u64 bss_size) { - return header.magic == Common::MakeMagic('N', 'R', 'O', '0') && - header.nro_size == nro_size && header.bss_size == bss_size && - - header.segment_headers[RO_INDEX].memory_offset == - header.segment_headers[TEXT_INDEX].memory_offset + - header.segment_headers[TEXT_INDEX].memory_size && - - header.segment_headers[DATA_INDEX].memory_offset == - header.segment_headers[RO_INDEX].memory_offset + - header.segment_headers[RO_INDEX].memory_size && - - nro_size == header.segment_headers[DATA_INDEX].memory_offset + - header.segment_headers[DATA_INDEX].memory_size && - - Common::Is4KBAligned(header.segment_headers[TEXT_INDEX].memory_size) && - Common::Is4KBAligned(header.segment_headers[RO_INDEX].memory_size) && - Common::Is4KBAligned(header.segment_headers[DATA_INDEX].memory_size); - } -}; - void LoopProcess(Core::System& system) { auto server_manager = std::make_unique(system); server_manager->RegisterNamedService("ldr:dmnt", std::make_shared(system)); server_manager->RegisterNamedService("ldr:pm", std::make_shared(system)); server_manager->RegisterNamedService("ldr:shel", std::make_shared(system)); - server_manager->RegisterNamedService("ldr:ro", std::make_shared(system)); ServerManager::RunServer(std::move(server_manager)); } 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 + +#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; + +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 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 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(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 m_nro_in_use{}; + std::array m_nrr_in_use{}; + std::array m_nro_infos{}; + std::array 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 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 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 m_ro{}; + size_t m_context_id{}; + NrrKind m_nrr_kind{}; +}; + +class IRoInterface : public ServiceFramework { +public: + explicit IRoInterface(Core::System& system_, const char* name_, std::shared_ptr 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(); + + 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(); + 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(); + 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(); + 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()); + + 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(); + 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()); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(result); + } + + RoInterface interface; +}; + +} // namespace + +void LoopProcess(Core::System& system) { + auto server_manager = std::make_unique(system); + + auto ro = std::make_shared(); + + const auto RoInterfaceFactoryForUser = [&, ro] { + return std::make_shared(system, "ldr:ro", ro, NrrKind::User); + }; + + const auto RoInterfaceFactoryForJitPlugin = [&, ro] { + return std::make_shared(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 diff --git a/src/core/hle/service/ro/ro.h b/src/core/hle/service/ro/ro.h new file mode 100644 index 000000000..74dc08536 --- /dev/null +++ b/src/core/hle/service/ro/ro.h @@ -0,0 +1,14 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +namespace Core { +class System; +} + +namespace Service::RO { + +void LoopProcess(Core::System& system); + +} // namespace Service::RO diff --git a/src/core/hle/service/ro/ro_nro_utils.cpp b/src/core/hle/service/ro/ro_nro_utils.cpp new file mode 100644 index 000000000..268c7f93e --- /dev/null +++ b/src/core/hle/service/ro/ro_nro_utils.cpp @@ -0,0 +1,185 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/kernel/k_process.h" +#include "core/hle/service/ro/ro_nro_utils.h" +#include "core/hle/service/ro/ro_results.h" + +namespace Service::RO { + +namespace { + +struct ProcessMemoryRegion { + u64 address; + u64 size; +}; + +size_t GetTotalProcessMemoryRegionSize(const ProcessMemoryRegion* regions, size_t num_regions) { + size_t total = 0; + + for (size_t i = 0; i < num_regions; ++i) { + total += regions[i].size; + } + + return total; +} + +size_t SetupNroProcessMemoryRegions(ProcessMemoryRegion* regions, u64 nro_heap_address, + u64 nro_heap_size, u64 bss_heap_address, u64 bss_heap_size) { + // Reset region count. + size_t num_regions = 0; + + // We always want a region for the nro. + regions[num_regions++] = {nro_heap_address, nro_heap_size}; + + // If we have bss, create a region for bss. + if (bss_heap_size > 0) { + regions[num_regions++] = {bss_heap_address, bss_heap_size}; + } + + return num_regions; +} + +Result SetProcessMemoryPermission(Kernel::KProcess* process, u64 address, u64 size, + Kernel::Svc::MemoryPermission permission) { + auto& page_table = process->GetPageTable(); + + // Set permission. + R_RETURN(page_table.SetProcessMemoryPermission(address, size, permission)); +} + +Result UnmapProcessCodeMemory(Kernel::KProcess* process, u64 process_code_address, + const ProcessMemoryRegion* regions, size_t num_regions) { + // Get the total process memory region size. + const size_t total_size = GetTotalProcessMemoryRegionSize(regions, num_regions); + + auto& page_table = process->GetPageTable(); + + // Unmap each region in order. + size_t cur_offset = total_size; + for (size_t i = 0; i < num_regions; ++i) { + // We want to unmap in reverse order. + const auto& cur_region = regions[num_regions - 1 - i]; + + // Subtract to update the current offset. + cur_offset -= cur_region.size; + + // Unmap. + R_TRY(page_table.UnmapCodeMemory(process_code_address + cur_offset, cur_region.address, + cur_region.size)); + } + + R_SUCCEED(); +} + +Result EnsureGuardPages(Kernel::KProcessPageTable& page_table, u64 map_address, u64 map_size) { + Kernel::KMemoryInfo memory_info; + Kernel::Svc::PageInfo page_info; + + // Ensure page before mapping is unmapped. + R_TRY(page_table.QueryInfo(std::addressof(memory_info), std::addressof(page_info), + map_address - 1)); + R_UNLESS(memory_info.GetSvcState() == Kernel::Svc::MemoryState::Free, + Kernel::ResultInvalidState); + + // Ensure page after mapping is unmapped. + R_TRY(page_table.QueryInfo(std::addressof(memory_info), std::addressof(page_info), + map_address + map_size)); + R_UNLESS(memory_info.GetSvcState() == Kernel::Svc::MemoryState::Free, + Kernel::ResultInvalidState); + + // Successfully verified guard pages. + R_SUCCEED(); +} + +Result MapProcessCodeMemory(u64* out, Kernel::KProcess* process, const ProcessMemoryRegion* regions, + size_t num_regions, std::mt19937_64& generate_random) { + auto& page_table = process->GetPageTable(); + const u64 alias_code_start = + GetInteger(page_table.GetAliasCodeRegionStart()) / Kernel::PageSize; + const u64 alias_code_size = page_table.GetAliasCodeRegionSize() / Kernel::PageSize; + + for (size_t trial = 0; trial < 64; trial++) { + // Generate a new trial address. + const u64 mapped_address = + (alias_code_start + (generate_random() % alias_code_size)) * Kernel::PageSize; + + const auto MapRegions = [&] { + // Map the regions in order. + u64 mapped_size = 0; + for (size_t i = 0; i < num_regions; ++i) { + // If we fail, unmap up to where we've mapped. + ON_RESULT_FAILURE { + R_ASSERT(UnmapProcessCodeMemory(process, mapped_address, regions, i)); + }; + + // Map the current region. + R_TRY(page_table.MapCodeMemory(mapped_address + mapped_size, regions[i].address, + regions[i].size)); + + mapped_size += regions[i].size; + } + + // If we fail, unmap all mapped regions. + ON_RESULT_FAILURE { + R_ASSERT(UnmapProcessCodeMemory(process, mapped_address, regions, num_regions)); + }; + + // Ensure guard pages. + R_RETURN(EnsureGuardPages(page_table, mapped_address, mapped_size)); + }; + + if (R_SUCCEEDED(MapRegions())) { + // Set the output address. + *out = mapped_address; + R_SUCCEED(); + } + } + + // We failed to map anything. + R_THROW(RO::ResultOutOfAddressSpace); +} + +} // namespace + +Result MapNro(u64* out_base_address, Kernel::KProcess* process, u64 nro_heap_address, + u64 nro_heap_size, u64 bss_heap_address, u64 bss_heap_size, + std::mt19937_64& generate_random) { + // Set up the process memory regions. + std::array regions{}; + const size_t num_regions = SetupNroProcessMemoryRegions( + regions.data(), nro_heap_address, nro_heap_size, bss_heap_address, bss_heap_size); + + // Re-map the nro/bss as code memory in the destination process. + R_RETURN(MapProcessCodeMemory(out_base_address, process, regions.data(), num_regions, + generate_random)); +} + +Result SetNroPerms(Kernel::KProcess* process, u64 base_address, u64 rx_size, u64 ro_size, + u64 rw_size) { + const u64 rx_offset = 0; + const u64 ro_offset = rx_offset + rx_size; + const u64 rw_offset = ro_offset + ro_size; + + R_TRY(SetProcessMemoryPermission(process, base_address + rx_offset, rx_size, + Kernel::Svc::MemoryPermission::ReadExecute)); + R_TRY(SetProcessMemoryPermission(process, base_address + ro_offset, ro_size, + Kernel::Svc::MemoryPermission::Read)); + R_TRY(SetProcessMemoryPermission(process, base_address + rw_offset, rw_size, + Kernel::Svc::MemoryPermission::ReadWrite)); + + R_SUCCEED(); +} + +Result UnmapNro(Kernel::KProcess* process, u64 base_address, u64 nro_heap_address, + u64 nro_heap_size, u64 bss_heap_address, u64 bss_heap_size) { + // Set up the process memory regions. + std::array regions{}; + const size_t num_regions = SetupNroProcessMemoryRegions( + regions.data(), nro_heap_address, nro_heap_size, bss_heap_address, bss_heap_size); + + // Unmap the nro/bss. + R_RETURN(UnmapProcessCodeMemory(process, base_address, regions.data(), num_regions)); +} + +} // namespace Service::RO diff --git a/src/core/hle/service/ro/ro_nro_utils.h b/src/core/hle/service/ro/ro_nro_utils.h new file mode 100644 index 000000000..f7083a1ba --- /dev/null +++ b/src/core/hle/service/ro/ro_nro_utils.h @@ -0,0 +1,26 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include + +#include "common/common_types.h" + +namespace Kernel { +class KProcess; +} + +union Result; + +namespace Service::RO { + +Result MapNro(u64* out_base_address, Kernel::KProcess* process, u64 nro_heap_address, + u64 nro_heap_size, u64 bss_heap_address, u64 bss_heap_size, + std::mt19937_64& generate_random); +Result SetNroPerms(Kernel::KProcess* process, u64 base_address, u64 rx_size, u64 ro_size, + u64 rw_size); +Result UnmapNro(Kernel::KProcess* process, u64 base_address, u64 nro_heap_address, + u64 nro_heap_size, u64 bss_heap_address, u64 bss_heap_size); + +} // namespace Service::RO diff --git a/src/core/hle/service/ro/ro_results.h b/src/core/hle/service/ro/ro_results.h new file mode 100644 index 000000000..00f05c5a5 --- /dev/null +++ b/src/core/hle/service/ro/ro_results.h @@ -0,0 +1,24 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/result.h" + +namespace Service::RO { + +constexpr Result ResultOutOfAddressSpace{ErrorModule::RO, 2}; +constexpr Result ResultAlreadyLoaded{ErrorModule::RO, 3}; +constexpr Result ResultInvalidNro{ErrorModule::RO, 4}; +constexpr Result ResultInvalidNrr{ErrorModule::RO, 6}; +constexpr Result ResultTooManyNro{ErrorModule::RO, 7}; +constexpr Result ResultTooManyNrr{ErrorModule::RO, 8}; +constexpr Result ResultNotAuthorized{ErrorModule::RO, 9}; +constexpr Result ResultInvalidNrrKind{ErrorModule::RO, 10}; +constexpr Result ResultInternalError{ErrorModule::RO, 1023}; +constexpr Result ResultInvalidAddress{ErrorModule::RO, 1025}; +constexpr Result ResultInvalidSize{ErrorModule::RO, 1026}; +constexpr Result ResultNotLoaded{ErrorModule::RO, 1028}; +constexpr Result ResultNotRegistered{ErrorModule::RO, 1029}; +constexpr Result ResultInvalidSession{ErrorModule::RO, 1030}; +constexpr Result ResultInvalidProcess{ErrorModule::RO, 1031}; + +} // namespace Service::RO diff --git a/src/core/hle/service/ro/ro_types.h b/src/core/hle/service/ro/ro_types.h new file mode 100644 index 000000000..624d52ee5 --- /dev/null +++ b/src/core/hle/service/ro/ro_types.h @@ -0,0 +1,181 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "common/assert.h" +#include "common/common_funcs.h" +#include "common/common_types.h" + +namespace Service::RO { + +enum class NrrKind : u8 { + User = 0, + JitPlugin = 1, + Count, +}; + +static constexpr size_t ModuleIdSize = 0x20; +struct ModuleId { + std::array data; +}; +static_assert(sizeof(ModuleId) == ModuleIdSize); + +struct NrrCertification { + static constexpr size_t RsaKeySize = 0x100; + static constexpr size_t SignedSize = 0x120; + + u64 program_id_mask; + u64 program_id_pattern; + std::array reserved_10; + std::array modulus; + std::array signature; +}; +static_assert(sizeof(NrrCertification) == + NrrCertification::RsaKeySize + NrrCertification::SignedSize); + +class NrrHeader { +public: + static constexpr u32 Magic = Common::MakeMagic('N', 'R', 'R', '0'); + +public: + bool IsMagicValid() const { + return m_magic == Magic; + } + + bool IsProgramIdValid() const { + return (m_program_id & m_certification.program_id_mask) == + m_certification.program_id_pattern; + } + + NrrKind GetNrrKind() const { + const NrrKind kind = static_cast(m_nrr_kind); + ASSERT(kind < NrrKind::Count); + return kind; + } + + u64 GetProgramId() const { + return m_program_id; + } + + u32 GetSize() const { + return m_size; + } + + u32 GetNumHashes() const { + return m_num_hashes; + } + + size_t GetHashesOffset() const { + return m_hashes_offset; + } + + u32 GetKeyGeneration() const { + return m_key_generation; + } + + const u8* GetCertificationSignature() const { + return m_certification.signature.data(); + } + + const u8* GetCertificationSignedArea() const { + return reinterpret_cast(std::addressof(m_certification)); + } + + const u8* GetCertificationModulus() const { + return m_certification.modulus.data(); + } + + const u8* GetSignature() const { + return m_signature.data(); + } + + size_t GetSignedAreaSize() const { + return m_size - GetSignedAreaOffset(); + } + + static constexpr size_t GetSignedAreaOffset() { + return offsetof(NrrHeader, m_program_id); + } + +private: + u32 m_magic; + u32 m_key_generation; + INSERT_PADDING_BYTES_NOINIT(8); + NrrCertification m_certification; + std::array m_signature; + u64 m_program_id; + u32 m_size; + u8 m_nrr_kind; // 7.0.0+ + INSERT_PADDING_BYTES_NOINIT(3); + u32 m_hashes_offset; + u32 m_num_hashes; + INSERT_PADDING_BYTES_NOINIT(8); +}; +static_assert(sizeof(NrrHeader) == 0x350, "NrrHeader has wrong size"); + +class NroHeader { +public: + static constexpr u32 Magic = Common::MakeMagic('N', 'R', 'O', '0'); + +public: + bool IsMagicValid() const { + return m_magic == Magic; + } + + u32 GetSize() const { + return m_size; + } + + u32 GetTextOffset() const { + return m_text_offset; + } + + u32 GetTextSize() const { + return m_text_size; + } + + u32 GetRoOffset() const { + return m_ro_offset; + } + + u32 GetRoSize() const { + return m_ro_size; + } + + u32 GetRwOffset() const { + return m_rw_offset; + } + + u32 GetRwSize() const { + return m_rw_size; + } + + u32 GetBssSize() const { + return m_bss_size; + } + + const ModuleId* GetModuleId() const { + return std::addressof(m_module_id); + } + +private: + u32 m_entrypoint_insn; + u32 m_mod_offset; + INSERT_PADDING_BYTES_NOINIT(0x8); + u32 m_magic; + INSERT_PADDING_BYTES_NOINIT(0x4); + u32 m_size; + INSERT_PADDING_BYTES_NOINIT(0x4); + u32 m_text_offset; + u32 m_text_size; + u32 m_ro_offset; + u32 m_ro_size; + u32 m_rw_offset; + u32 m_rw_size; + u32 m_bss_size; + INSERT_PADDING_BYTES_NOINIT(0x4); + ModuleId m_module_id; + INSERT_PADDING_BYTES_NOINIT(0x20); +}; +static_assert(sizeof(NroHeader) == 0x80, "NroHeader has wrong size"); + +} // namespace Service::RO diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp index 0ad607391..00531b021 100644 --- a/src/core/hle/service/service.cpp +++ b/src/core/hle/service/service.cpp @@ -59,6 +59,7 @@ #include "core/hle/service/prepo/prepo.h" #include "core/hle/service/psc/psc.h" #include "core/hle/service/ptm/ptm.h" +#include "core/hle/service/ro/ro.h" #include "core/hle/service/service.h" #include "core/hle/service/set/settings.h" #include "core/hle/service/sm/sm.h" @@ -270,6 +271,7 @@ Services::Services(std::shared_ptr& sm, Core::System& system kernel.RunOnGuestCoreProcess("ProcessManager", [&] { PM::LoopProcess(system); }); kernel.RunOnGuestCoreProcess("psc", [&] { PSC::LoopProcess(system); }); kernel.RunOnGuestCoreProcess("ptm", [&] { PTM::LoopProcess(system); }); + kernel.RunOnGuestCoreProcess("ro", [&] { RO::LoopProcess(system); }); kernel.RunOnGuestCoreProcess("settings", [&] { Set::LoopProcess(system); }); kernel.RunOnGuestCoreProcess("spl", [&] { SPL::LoopProcess(system); }); kernel.RunOnGuestCoreProcess("ssl", [&] { SSL::LoopProcess(system); });