diff options
Diffstat (limited to 'src/core')
132 files changed, 7125 insertions, 5081 deletions
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 85583941c..dced37079 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -4,6 +4,8 @@ add_library(core STATIC arm/arm_interface.h arm/arm_interface.cpp + arm/debug.cpp + arm/debug.h arm/exclusive_monitor.cpp arm/exclusive_monitor.h arm/symbols.cpp @@ -249,10 +251,16 @@ add_library(core STATIC hle/kernel/k_hardware_timer.h hle/kernel/k_interrupt_manager.cpp hle/kernel/k_interrupt_manager.h + hle/kernel/k_light_client_session.cpp + hle/kernel/k_light_client_session.h hle/kernel/k_light_condition_variable.cpp hle/kernel/k_light_condition_variable.h hle/kernel/k_light_lock.cpp hle/kernel/k_light_lock.h + hle/kernel/k_light_server_session.cpp + hle/kernel/k_light_server_session.h + hle/kernel/k_light_session.cpp + hle/kernel/k_light_session.h hle/kernel/k_memory_block.h hle/kernel/k_memory_block_manager.cpp hle/kernel/k_memory_block_manager.h @@ -541,6 +549,13 @@ add_library(core STATIC hle/service/hid/xcd.cpp hle/service/hid/xcd.h hle/service/hid/errors.h + hle/service/hid/controllers/types/debug_pad_types.h + hle/service/hid/controllers/types/keyboard_types.h + hle/service/hid/controllers/types/mouse_types.h + hle/service/hid/controllers/types/npad_types.h + hle/service/hid/controllers/types/touch_types.h + hle/service/hid/controllers/applet_resource.cpp + hle/service/hid/controllers/applet_resource.h hle/service/hid/controllers/console_six_axis.cpp hle/service/hid/controllers/console_six_axis.h hle/service/hid/controllers/controller_base.cpp @@ -559,14 +574,15 @@ add_library(core STATIC hle/service/hid/controllers/palma.h hle/service/hid/controllers/seven_six_axis.cpp hle/service/hid/controllers/seven_six_axis.h + hle/service/hid/controllers/shared_memory_format.h + hle/service/hid/controllers/shared_memory_holder.cpp + hle/service/hid/controllers/shared_memory_holder.h hle/service/hid/controllers/six_axis.cpp hle/service/hid/controllers/six_axis.h hle/service/hid/controllers/stubbed.cpp hle/service/hid/controllers/stubbed.h hle/service/hid/controllers/touchscreen.cpp hle/service/hid/controllers/touchscreen.h - hle/service/hid/controllers/xpad.cpp - hle/service/hid/controllers/xpad.h hle/service/hid/hidbus/hidbus_base.cpp hle/service/hid/hidbus/hidbus_base.h hle/service/hid/hidbus/ringcon.cpp @@ -762,6 +778,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/arm/arm_interface.cpp b/src/core/arm/arm_interface.cpp index d231bf89c..698c9c8ad 100644 --- a/src/core/arm/arm_interface.cpp +++ b/src/core/arm/arm_interface.cpp @@ -1,231 +1,32 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <map> -#include <optional> - -#include "common/bit_field.h" -#include "common/common_types.h" -#include "common/demangle.h" #include "common/logging/log.h" #include "core/arm/arm_interface.h" -#include "core/arm/symbols.h" +#include "core/arm/debug.h" #include "core/core.h" -#include "core/debugger/debugger.h" #include "core/hle/kernel/k_process.h" -#include "core/hle/kernel/k_thread.h" -#include "core/hle/kernel/svc.h" -#include "core/loader/loader.h" -#include "core/memory.h" namespace Core { -constexpr u64 SEGMENT_BASE = 0x7100000000ull; - -std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktraceFromContext( - Core::System& system, const ARM_Interface::ThreadContext32& ctx) { - std::vector<BacktraceEntry> out; - auto& memory = system.ApplicationMemory(); - - const auto& reg = ctx.cpu_registers; - u32 pc = reg[15], lr = reg[14], fp = reg[11]; - out.push_back({"", 0, pc, 0, ""}); - - // fp (= r11) points to the last frame record. - // Frame records are two words long: - // fp+0 : pointer to previous frame record - // fp+4 : value of lr for frame - for (size_t i = 0; i < 256; i++) { - out.push_back({"", 0, lr, 0, ""}); - if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 8)) { - break; - } - lr = memory.Read32(fp + 4); - fp = memory.Read32(fp); - } - - SymbolicateBacktrace(system, out); - - return out; -} - -std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktraceFromContext( - Core::System& system, const ARM_Interface::ThreadContext64& ctx) { - std::vector<BacktraceEntry> out; - auto& memory = system.ApplicationMemory(); - - const auto& reg = ctx.cpu_registers; - u64 pc = ctx.pc, lr = reg[30], fp = reg[29]; - - out.push_back({"", 0, pc, 0, ""}); - - // fp (= x29) points to the previous frame record. - // Frame records are two words long: - // fp+0 : pointer to previous frame record - // fp+8 : value of lr for frame - for (size_t i = 0; i < 256; i++) { - out.push_back({"", 0, lr, 0, ""}); - if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) { - break; - } - lr = memory.Read64(fp + 8); - fp = memory.Read64(fp); - } - - SymbolicateBacktrace(system, out); - - return out; -} - -void ARM_Interface::SymbolicateBacktrace(Core::System& system, std::vector<BacktraceEntry>& out) { - std::map<VAddr, std::string> modules; - auto& loader{system.GetAppLoader()}; - if (loader.ReadNSOModules(modules) != Loader::ResultStatus::Success) { - return; - } - - std::map<std::string, Symbols::Symbols> symbols; - for (const auto& module : modules) { - symbols.insert_or_assign(module.second, - Symbols::GetSymbols(module.first, system.ApplicationMemory(), - system.ApplicationProcess()->Is64Bit())); - } - - for (auto& entry : out) { - VAddr base = 0; - for (auto iter = modules.rbegin(); iter != modules.rend(); ++iter) { - const auto& module{*iter}; - if (entry.original_address >= module.first) { - entry.module = module.second; - base = module.first; - break; - } - } - - entry.offset = entry.original_address - base; - entry.address = SEGMENT_BASE + entry.offset; - - if (entry.module.empty()) { - entry.module = "unknown"; - } - - const auto symbol_set = symbols.find(entry.module); - if (symbol_set != symbols.end()) { - const auto symbol = Symbols::GetSymbolName(symbol_set->second, entry.offset); - if (symbol) { - entry.name = Common::DemangleSymbol(*symbol); - } - } - } -} - -std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktrace() const { - if (GetArchitecture() == Architecture::Aarch64) { - ThreadContext64 ctx; - SaveContext(ctx); - return GetBacktraceFromContext(system, ctx); - } else { - ThreadContext32 ctx; - SaveContext(ctx); - return GetBacktraceFromContext(system, ctx); - } -} +void ArmInterface::LogBacktrace(const Kernel::KProcess* process) const { + Kernel::Svc::ThreadContext ctx; + this->GetContext(ctx); -void ARM_Interface::LogBacktrace() const { - const VAddr sp = GetSP(); - const VAddr pc = GetPC(); - LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", sp, pc); + LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", ctx.sp, ctx.pc); LOG_ERROR(Core_ARM, "{:20}{:20}{:20}{:20}{}", "Module Name", "Address", "Original Address", "Offset", "Symbol"); LOG_ERROR(Core_ARM, ""); - const auto backtrace = GetBacktrace(); + const auto backtrace = GetBacktraceFromContext(process, ctx); for (const auto& entry : backtrace) { LOG_ERROR(Core_ARM, "{:20}{:016X} {:016X} {:016X} {}", entry.module, entry.address, entry.original_address, entry.offset, entry.name); } } -void ARM_Interface::Run() { - using Kernel::StepState; - using Kernel::SuspendType; - - while (true) { - Kernel::KThread* current_thread{Kernel::GetCurrentThreadPointer(system.Kernel())}; - HaltReason hr{}; - - // If the thread is scheduled for termination, exit the thread. - if (current_thread->HasDpc()) { - if (current_thread->IsTerminationRequested()) { - current_thread->Exit(); - UNREACHABLE(); - } - } - - // Notify the debugger and go to sleep if a step was performed - // and this thread has been scheduled again. - if (current_thread->GetStepState() == StepState::StepPerformed) { - system.GetDebugger().NotifyThreadStopped(current_thread); - current_thread->RequestSuspend(SuspendType::Debug); - break; - } - - // Otherwise, run the thread. - system.EnterCPUProfile(); - if (current_thread->GetStepState() == StepState::StepPending) { - hr = StepJit(); - - if (True(hr & HaltReason::StepThread)) { - current_thread->SetStepState(StepState::StepPerformed); - } - } else { - hr = RunJit(); - } - system.ExitCPUProfile(); - - // Notify the debugger and go to sleep if a breakpoint was hit, - // or if the thread is unable to continue for any reason. - if (True(hr & HaltReason::InstructionBreakpoint) || True(hr & HaltReason::PrefetchAbort)) { - if (!True(hr & HaltReason::PrefetchAbort)) { - RewindBreakpointInstruction(); - } - if (system.DebuggerEnabled()) { - system.GetDebugger().NotifyThreadStopped(current_thread); - } else { - LogBacktrace(); - } - current_thread->RequestSuspend(SuspendType::Debug); - break; - } - - // Notify the debugger and go to sleep if a watchpoint was hit. - if (True(hr & HaltReason::DataAbort)) { - if (system.DebuggerEnabled()) { - system.GetDebugger().NotifyThreadWatchpoint(current_thread, *HaltedWatchpoint()); - } else { - LogBacktrace(); - } - current_thread->RequestSuspend(SuspendType::Debug); - break; - } - - // Handle syscalls and scheduling (this may change the current thread/core) - if (True(hr & HaltReason::SupervisorCall)) { - Kernel::Svc::Call(system, GetSvcNumber()); - break; - } - if (True(hr & HaltReason::BreakLoop) || !uses_wall_clock) { - break; - } - } -} - -void ARM_Interface::LoadWatchpointArray(const WatchpointArray* wp) { - watchpoints = wp; -} - -const Kernel::DebugWatchpoint* ARM_Interface::MatchingWatchpoint( +const Kernel::DebugWatchpoint* ArmInterface::MatchingWatchpoint( u64 addr, u64 size, Kernel::DebugWatchpointType access_type) const { - if (!watchpoints) { + if (!m_watchpoints) { return nullptr; } @@ -233,7 +34,7 @@ const Kernel::DebugWatchpoint* ARM_Interface::MatchingWatchpoint( const u64 end_address{addr + size}; for (size_t i = 0; i < Core::Hardware::NUM_WATCHPOINTS; i++) { - const auto& watch{(*watchpoints)[i]}; + const auto& watch{(*m_watchpoints)[i]}; if (end_address <= GetInteger(watch.start_address)) { continue; diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h index a9d9ac09d..806c7c9e9 100644 --- a/src/core/arm/arm_interface.h +++ b/src/core/arm/arm_interface.h @@ -12,20 +12,20 @@ #include "common/common_types.h" #include "core/hardware_properties.h" +#include "core/hle/kernel/svc_types.h" + namespace Common { struct PageTable; } namespace Kernel { -enum class VMAPermission : u8; enum class DebugWatchpointType : u8; struct DebugWatchpoint; +class KThread; +class KProcess; } // namespace Kernel namespace Core { -class System; -class CPUInterruptHandler; - using WatchpointArray = std::array<Kernel::DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS>; // NOTE: these values match the HaltReason enum in Dynarmic @@ -40,197 +40,74 @@ enum class HaltReason : u64 { DECLARE_ENUM_FLAG_OPERATORS(HaltReason); enum class Architecture { - Aarch32, - Aarch64, + AArch64, + AArch32, }; /// Generic ARMv8 CPU interface -class ARM_Interface { +class ArmInterface { public: - YUZU_NON_COPYABLE(ARM_Interface); - YUZU_NON_MOVEABLE(ARM_Interface); - - explicit ARM_Interface(System& system_, bool uses_wall_clock_) - : system{system_}, uses_wall_clock{uses_wall_clock_} {} - virtual ~ARM_Interface() = default; - - struct ThreadContext32 { - std::array<u32, 16> cpu_registers{}; - std::array<u32, 64> extension_registers{}; - u32 cpsr{}; - u32 fpscr{}; - u32 fpexc{}; - u32 tpidr{}; - }; - // Internally within the kernel, it expects the AArch32 version of the - // thread context to be 344 bytes in size. - static_assert(sizeof(ThreadContext32) == 0x150); - - struct ThreadContext64 { - std::array<u64, 31> cpu_registers{}; - u64 sp{}; - u64 pc{}; - u32 pstate{}; - std::array<u8, 4> padding{}; - std::array<u128, 32> vector_registers{}; - u32 fpcr{}; - u32 fpsr{}; - u64 tpidr{}; - }; - // Internally within the kernel, it expects the AArch64 version of the - // thread context to be 800 bytes in size. - static_assert(sizeof(ThreadContext64) == 0x320); - - /// Perform any backend-specific initialization. + YUZU_NON_COPYABLE(ArmInterface); + YUZU_NON_MOVEABLE(ArmInterface); + + explicit ArmInterface(bool uses_wall_clock) : m_uses_wall_clock{uses_wall_clock} {} + virtual ~ArmInterface() = default; + + // Perform any backend-specific initialization. virtual void Initialize() {} - /// Runs the CPU until an event happens - void Run(); + // Runs the CPU until an event happens. + virtual HaltReason RunThread(Kernel::KThread* thread) = 0; - /// Clear all instruction cache + // Runs the CPU for one instruction or until an event happens. + virtual HaltReason StepThread(Kernel::KThread* thread) = 0; + + // Admits a backend-specific mechanism to lock the thread context. + virtual void LockThread(Kernel::KThread* thread) {} + virtual void UnlockThread(Kernel::KThread* thread) {} + + // Clear the entire instruction cache for this CPU. virtual void ClearInstructionCache() = 0; - /** - * Clear instruction cache range - * @param addr Start address of the cache range to clear - * @param size Size of the cache range to clear, starting at addr - */ + // Clear a range of the instruction cache for this CPU. virtual void InvalidateCacheRange(u64 addr, std::size_t size) = 0; - /** - * Notifies CPU emulation that the current page table has changed. - * @param new_page_table The new page table. - * @param new_address_space_size_in_bits The new usable size of the address space in bits. - * This can be either 32, 36, or 39 on official software. - */ - virtual void PageTableChanged(Common::PageTable& new_page_table, - std::size_t new_address_space_size_in_bits) = 0; - - /** - * Set the Program Counter to an address - * @param addr Address to set PC to - */ - virtual void SetPC(u64 addr) = 0; - - /* - * Get the current Program Counter - * @return Returns current PC - */ - virtual u64 GetPC() const = 0; - - /** - * Get the current Stack Pointer - * @return Returns current SP - */ - virtual u64 GetSP() const = 0; - - /** - * Get an ARM register - * @param index Register index - * @return Returns the value in the register - */ - virtual u64 GetReg(int index) const = 0; - - /** - * Set an ARM register - * @param index Register index - * @param value Value to set register to - */ - virtual void SetReg(int index, u64 value) = 0; - - /** - * Gets the value of a specified vector register. - * - * @param index The index of the vector register. - * @return the value within the vector register. - */ - virtual u128 GetVectorReg(int index) const = 0; - - /** - * Sets a given value into a vector register. - * - * @param index The index of the vector register. - * @param value The new value to place in the register. - */ - virtual void SetVectorReg(int index, u128 value) = 0; - - /** - * Get the current PSTATE register - * @return Returns the value of the PSTATE register - */ - virtual u32 GetPSTATE() const = 0; - - /** - * Set the current PSTATE register - * @param pstate Value to set PSTATE to - */ - virtual void SetPSTATE(u32 pstate) = 0; - - virtual u64 GetTlsAddress() const = 0; - - virtual void SetTlsAddress(u64 address) = 0; - - /** - * Gets the value within the TPIDR_EL0 (read/write software thread ID) register. - * - * @return the value within the register. - */ - virtual u64 GetTPIDR_EL0() const = 0; - - /** - * Sets a new value within the TPIDR_EL0 (read/write software thread ID) register. - * - * @param value The new value to place in the register. - */ - virtual void SetTPIDR_EL0(u64 value) = 0; - + // Get the current architecture. + // This returns AArch64 when PSTATE.nRW == 0 and AArch32 when PSTATE.nRW == 1. virtual Architecture GetArchitecture() const = 0; - virtual void SaveContext(ThreadContext32& ctx) const = 0; - virtual void SaveContext(ThreadContext64& ctx) const = 0; - virtual void LoadContext(const ThreadContext32& ctx) = 0; - virtual void LoadContext(const ThreadContext64& ctx) = 0; - void LoadWatchpointArray(const WatchpointArray* wp); - /// Clears the exclusive monitor's state. - virtual void ClearExclusiveState() = 0; + // Context accessors. + // These should not be called if the CPU is running. + virtual void GetContext(Kernel::Svc::ThreadContext& ctx) const = 0; + virtual void SetContext(const Kernel::Svc::ThreadContext& ctx) = 0; + virtual void SetTpidrroEl0(u64 value) = 0; - /// Signal an interrupt and ask the core to halt as soon as possible. - virtual void SignalInterrupt() = 0; + virtual void GetSvcArguments(std::span<uint64_t, 8> args) const = 0; + virtual void SetSvcArguments(std::span<const uint64_t, 8> args) = 0; + virtual u32 GetSvcNumber() const = 0; - /// Clear a previous interrupt. - virtual void ClearInterrupt() = 0; + void SetWatchpointArray(const WatchpointArray* watchpoints) { + m_watchpoints = watchpoints; + } - struct BacktraceEntry { - std::string module; - u64 address; - u64 original_address; - u64 offset; - std::string name; - }; + // Signal an interrupt for execution to halt as soon as possible. + // It is safe to call this if the CPU is not running. + virtual void SignalInterrupt(Kernel::KThread* thread) = 0; - static std::vector<BacktraceEntry> GetBacktraceFromContext(System& system, - const ThreadContext32& ctx); - static std::vector<BacktraceEntry> GetBacktraceFromContext(System& system, - const ThreadContext64& ctx); + // Stack trace generation. + void LogBacktrace(const Kernel::KProcess* process) const; - std::vector<BacktraceEntry> GetBacktrace() const; - void LogBacktrace() const; + // Debug functionality. + virtual const Kernel::DebugWatchpoint* HaltedWatchpoint() const = 0; + virtual void RewindBreakpointInstruction() = 0; protected: - /// System context that this ARM interface is running under. - System& system; - const WatchpointArray* watchpoints; - bool uses_wall_clock; - - static void SymbolicateBacktrace(Core::System& system, std::vector<BacktraceEntry>& out); const Kernel::DebugWatchpoint* MatchingWatchpoint( u64 addr, u64 size, Kernel::DebugWatchpointType access_type) const; - virtual HaltReason RunJit() = 0; - virtual HaltReason StepJit() = 0; - virtual u32 GetSvcNumber() const = 0; - virtual const Kernel::DebugWatchpoint* HaltedWatchpoint() const = 0; - virtual void RewindBreakpointInstruction() = 0; +protected: + const WatchpointArray* m_watchpoints{}; + bool m_uses_wall_clock{}; }; } // namespace Core diff --git a/src/core/arm/debug.cpp b/src/core/arm/debug.cpp new file mode 100644 index 000000000..af1c34bc3 --- /dev/null +++ b/src/core/arm/debug.cpp @@ -0,0 +1,354 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "common/demangle.h" +#include "core/arm/debug.h" +#include "core/arm/symbols.h" +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_thread.h" +#include "core/memory.h" + +namespace Core { + +namespace { + +std::optional<std::string> GetNameFromThreadType64(Core::Memory::Memory& memory, + const Kernel::KThread& thread) { + // Read thread type from TLS + const VAddr tls_thread_type{memory.Read64(thread.GetTlsAddress() + 0x1f8)}; + const VAddr argument_thread_type{thread.GetArgument()}; + + if (argument_thread_type && tls_thread_type != argument_thread_type) { + // Probably not created by nnsdk, no name available. + return std::nullopt; + } + + if (!tls_thread_type) { + return std::nullopt; + } + + const u16 version{memory.Read16(tls_thread_type + 0x46)}; + VAddr name_pointer{}; + if (version == 1) { + name_pointer = memory.Read64(tls_thread_type + 0x1a0); + } else { + name_pointer = memory.Read64(tls_thread_type + 0x1a8); + } + + if (!name_pointer) { + // No name provided. + return std::nullopt; + } + + return memory.ReadCString(name_pointer, 256); +} + +std::optional<std::string> GetNameFromThreadType32(Core::Memory::Memory& memory, + const Kernel::KThread& thread) { + // Read thread type from TLS + const VAddr tls_thread_type{memory.Read32(thread.GetTlsAddress() + 0x1fc)}; + const VAddr argument_thread_type{thread.GetArgument()}; + + if (argument_thread_type && tls_thread_type != argument_thread_type) { + // Probably not created by nnsdk, no name available. + return std::nullopt; + } + + if (!tls_thread_type) { + return std::nullopt; + } + + const u16 version{memory.Read16(tls_thread_type + 0x26)}; + VAddr name_pointer{}; + if (version == 1) { + name_pointer = memory.Read32(tls_thread_type + 0xe4); + } else { + name_pointer = memory.Read32(tls_thread_type + 0xe8); + } + + if (!name_pointer) { + // No name provided. + return std::nullopt; + } + + return memory.ReadCString(name_pointer, 256); +} + +constexpr std::array<u64, 2> SegmentBases{ + 0x60000000ULL, + 0x7100000000ULL, +}; + +void SymbolicateBacktrace(const Kernel::KProcess* process, std::vector<BacktraceEntry>& out) { + auto modules = FindModules(process); + + const bool is_64 = process->Is64Bit(); + + std::map<std::string, Symbols::Symbols> symbols; + for (const auto& module : modules) { + symbols.insert_or_assign(module.second, + Symbols::GetSymbols(module.first, process->GetMemory(), is_64)); + } + + for (auto& entry : out) { + VAddr base = 0; + for (auto iter = modules.rbegin(); iter != modules.rend(); ++iter) { + const auto& module{*iter}; + if (entry.original_address >= module.first) { + entry.module = module.second; + base = module.first; + break; + } + } + + entry.offset = entry.original_address - base; + entry.address = SegmentBases[is_64] + entry.offset; + + if (entry.module.empty()) { + entry.module = "unknown"; + } + + const auto symbol_set = symbols.find(entry.module); + if (symbol_set != symbols.end()) { + const auto symbol = Symbols::GetSymbolName(symbol_set->second, entry.offset); + if (symbol) { + entry.name = Common::DemangleSymbol(*symbol); + } + } + } +} + +std::vector<BacktraceEntry> GetAArch64Backtrace(const Kernel::KProcess* process, + const Kernel::Svc::ThreadContext& ctx) { + std::vector<BacktraceEntry> out; + auto& memory = process->GetMemory(); + auto pc = ctx.pc, lr = ctx.lr, fp = ctx.fp; + + out.push_back({"", 0, pc, 0, ""}); + + // fp (= x29) points to the previous frame record. + // Frame records are two words long: + // fp+0 : pointer to previous frame record + // fp+8 : value of lr for frame + for (size_t i = 0; i < 256; i++) { + out.push_back({"", 0, lr, 0, ""}); + if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) { + break; + } + lr = memory.Read64(fp + 8); + fp = memory.Read64(fp); + } + + SymbolicateBacktrace(process, out); + + return out; +} + +std::vector<BacktraceEntry> GetAArch32Backtrace(const Kernel::KProcess* process, + const Kernel::Svc::ThreadContext& ctx) { + std::vector<BacktraceEntry> out; + auto& memory = process->GetMemory(); + auto pc = ctx.pc, lr = ctx.lr, fp = ctx.fp; + + out.push_back({"", 0, pc, 0, ""}); + + // fp (= r11) points to the last frame record. + // Frame records are two words long: + // fp+0 : pointer to previous frame record + // fp+4 : value of lr for frame + for (size_t i = 0; i < 256; i++) { + out.push_back({"", 0, lr, 0, ""}); + if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 8)) { + break; + } + lr = memory.Read32(fp + 4); + fp = memory.Read32(fp); + } + + SymbolicateBacktrace(process, out); + + return out; +} + +} // namespace + +std::optional<std::string> GetThreadName(const Kernel::KThread* thread) { + const auto* process = thread->GetOwnerProcess(); + if (process->Is64Bit()) { + return GetNameFromThreadType64(process->GetMemory(), *thread); + } else { + return GetNameFromThreadType32(process->GetMemory(), *thread); + } +} + +std::string_view GetThreadWaitReason(const Kernel::KThread* thread) { + switch (thread->GetWaitReasonForDebugging()) { + case Kernel::ThreadWaitReasonForDebugging::Sleep: + return "Sleep"; + case Kernel::ThreadWaitReasonForDebugging::IPC: + return "IPC"; + case Kernel::ThreadWaitReasonForDebugging::Synchronization: + return "Synchronization"; + case Kernel::ThreadWaitReasonForDebugging::ConditionVar: + return "ConditionVar"; + case Kernel::ThreadWaitReasonForDebugging::Arbitration: + return "Arbitration"; + case Kernel::ThreadWaitReasonForDebugging::Suspended: + return "Suspended"; + default: + return "Unknown"; + } +} + +std::string GetThreadState(const Kernel::KThread* thread) { + switch (thread->GetState()) { + case Kernel::ThreadState::Initialized: + return "Initialized"; + case Kernel::ThreadState::Waiting: + return fmt::format("Waiting ({})", GetThreadWaitReason(thread)); + case Kernel::ThreadState::Runnable: + return "Runnable"; + case Kernel::ThreadState::Terminated: + return "Terminated"; + default: + return "Unknown"; + } +} + +Kernel::KProcessAddress GetModuleEnd(const Kernel::KProcess* process, + Kernel::KProcessAddress base) { + Kernel::KMemoryInfo mem_info; + Kernel::Svc::MemoryInfo svc_mem_info; + Kernel::Svc::PageInfo page_info; + VAddr cur_addr{GetInteger(base)}; + auto& page_table = process->GetPageTable(); + + // Expect: r-x Code (.text) + R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); + svc_mem_info = mem_info.GetSvcMemoryInfo(); + cur_addr = svc_mem_info.base_address + svc_mem_info.size; + if (svc_mem_info.state != Kernel::Svc::MemoryState::Code || + svc_mem_info.permission != Kernel::Svc::MemoryPermission::ReadExecute) { + return cur_addr - 1; + } + + // Expect: r-- Code (.rodata) + R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); + svc_mem_info = mem_info.GetSvcMemoryInfo(); + cur_addr = svc_mem_info.base_address + svc_mem_info.size; + if (svc_mem_info.state != Kernel::Svc::MemoryState::Code || + svc_mem_info.permission != Kernel::Svc::MemoryPermission::Read) { + return cur_addr - 1; + } + + // Expect: rw- CodeData (.data) + R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); + svc_mem_info = mem_info.GetSvcMemoryInfo(); + cur_addr = svc_mem_info.base_address + svc_mem_info.size; + return cur_addr - 1; +} + +Loader::AppLoader::Modules FindModules(const Kernel::KProcess* process) { + Loader::AppLoader::Modules modules; + + auto& page_table = process->GetPageTable(); + auto& memory = process->GetMemory(); + VAddr cur_addr = 0; + + // Look for executable sections in Code or AliasCode regions. + while (true) { + Kernel::KMemoryInfo mem_info{}; + Kernel::Svc::PageInfo page_info{}; + R_ASSERT( + page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); + auto svc_mem_info = mem_info.GetSvcMemoryInfo(); + + if (svc_mem_info.permission == Kernel::Svc::MemoryPermission::ReadExecute && + (svc_mem_info.state == Kernel::Svc::MemoryState::Code || + svc_mem_info.state == Kernel::Svc::MemoryState::AliasCode)) { + // Try to read the module name from its path. + constexpr s32 PathLengthMax = 0x200; + struct { + u32 zero; + s32 path_length; + std::array<char, PathLengthMax> path; + } module_path; + + if (memory.ReadBlock(svc_mem_info.base_address + svc_mem_info.size, &module_path, + sizeof(module_path))) { + if (module_path.zero == 0 && module_path.path_length > 0) { + // Truncate module name. + module_path.path[PathLengthMax - 1] = '\0'; + + // Ignore leading directories. + char* path_pointer = module_path.path.data(); + char* path_end = + path_pointer + std::min(PathLengthMax, module_path.path_length); + + for (s32 i = 0; i < std::min(PathLengthMax, module_path.path_length) && + module_path.path[i] != '\0'; + i++) { + if (module_path.path[i] == '/' || module_path.path[i] == '\\') { + path_pointer = module_path.path.data() + i + 1; + } + } + + // Insert output. + modules.emplace(svc_mem_info.base_address, + std::string_view(path_pointer, path_end)); + } + } + } + + // Check if we're done. + const uintptr_t next_address = svc_mem_info.base_address + svc_mem_info.size; + if (next_address <= cur_addr) { + break; + } + + cur_addr = next_address; + } + + return modules; +} + +Kernel::KProcessAddress FindMainModuleEntrypoint(const Kernel::KProcess* process) { + // Do we have any loaded executable sections? + auto modules = FindModules(process); + + if (modules.size() >= 2) { + // If we have two or more, the first one is rtld and the second is main. + return std::next(modules.begin())->first; + } else if (!modules.empty()) { + // If we only have one, this is the main module. + return modules.begin()->first; + } + + // As a last resort, use the start of the code region. + return GetInteger(process->GetPageTable().GetCodeRegionStart()); +} + +void InvalidateInstructionCacheRange(const Kernel::KProcess* process, u64 address, u64 size) { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + auto* interface = process->GetArmInterface(i); + if (interface) { + interface->InvalidateCacheRange(address, size); + } + } +} + +std::vector<BacktraceEntry> GetBacktraceFromContext(const Kernel::KProcess* process, + const Kernel::Svc::ThreadContext& ctx) { + if (process->Is64Bit()) { + return GetAArch64Backtrace(process, ctx); + } else { + return GetAArch32Backtrace(process, ctx); + } +} + +std::vector<BacktraceEntry> GetBacktrace(const Kernel::KThread* thread) { + Kernel::Svc::ThreadContext ctx = thread->GetContext(); + return GetBacktraceFromContext(thread->GetOwnerProcess(), ctx); +} + +} // namespace Core diff --git a/src/core/arm/debug.h b/src/core/arm/debug.h new file mode 100644 index 000000000..c542633db --- /dev/null +++ b/src/core/arm/debug.h @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include <optional> + +#include "core/hle/kernel/k_thread.h" +#include "core/loader/loader.h" + +namespace Core { + +std::optional<std::string> GetThreadName(const Kernel::KThread* thread); +std::string_view GetThreadWaitReason(const Kernel::KThread* thread); +std::string GetThreadState(const Kernel::KThread* thread); + +Loader::AppLoader::Modules FindModules(const Kernel::KProcess* process); +Kernel::KProcessAddress GetModuleEnd(const Kernel::KProcess* process, Kernel::KProcessAddress base); +Kernel::KProcessAddress FindMainModuleEntrypoint(const Kernel::KProcess* process); + +void InvalidateInstructionCacheRange(const Kernel::KProcess* process, u64 address, u64 size); + +struct BacktraceEntry { + std::string module; + u64 address; + u64 original_address; + u64 offset; + std::string name; +}; + +std::vector<BacktraceEntry> GetBacktraceFromContext(const Kernel::KProcess* process, + const Kernel::Svc::ThreadContext& ctx); +std::vector<BacktraceEntry> GetBacktrace(const Kernel::KThread* thread); + +} // namespace Core diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.cpp b/src/core/arm/dynarmic/arm_dynarmic_32.cpp index 44a297cdc..f34865e26 100644 --- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp +++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp @@ -1,25 +1,13 @@ // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <cinttypes> -#include <memory> -#include <dynarmic/interface/A32/a32.h> -#include <dynarmic/interface/A32/config.h> -#include "common/assert.h" -#include "common/literals.h" -#include "common/logging/log.h" -#include "common/page_table.h" #include "common/settings.h" #include "core/arm/dynarmic/arm_dynarmic.h" #include "core/arm/dynarmic/arm_dynarmic_32.h" #include "core/arm/dynarmic/dynarmic_cp15.h" #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h" -#include "core/core.h" #include "core/core_timing.h" -#include "core/debugger/debugger.h" #include "core/hle/kernel/k_process.h" -#include "core/hle/kernel/svc.h" -#include "core/memory.h" namespace Core { @@ -27,78 +15,78 @@ using namespace Common::Literals; class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks { public: - explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_) - : parent{parent_}, memory(parent.system.ApplicationMemory()), - debugger_enabled{parent.system.DebuggerEnabled()}, - check_memory_access{debugger_enabled || - !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {} + explicit DynarmicCallbacks32(ArmDynarmic32& parent, const Kernel::KProcess* process) + : m_parent{parent}, m_memory(process->GetMemory()), + m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()}, + m_check_memory_access{m_debugger_enabled || + !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {} u8 MemoryRead8(u32 vaddr) override { CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read); - return memory.Read8(vaddr); + return m_memory.Read8(vaddr); } u16 MemoryRead16(u32 vaddr) override { CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read); - return memory.Read16(vaddr); + return m_memory.Read16(vaddr); } u32 MemoryRead32(u32 vaddr) override { CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read); - return memory.Read32(vaddr); + return m_memory.Read32(vaddr); } u64 MemoryRead64(u32 vaddr) override { CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read); - return memory.Read64(vaddr); + return m_memory.Read64(vaddr); } std::optional<u32> MemoryReadCode(u32 vaddr) override { - if (!memory.IsValidVirtualAddressRange(vaddr, sizeof(u32))) { + if (!m_memory.IsValidVirtualAddressRange(vaddr, sizeof(u32))) { return std::nullopt; } - return memory.Read32(vaddr); + return m_memory.Read32(vaddr); } void MemoryWrite8(u32 vaddr, u8 value) override { if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) { - memory.Write8(vaddr, value); + m_memory.Write8(vaddr, value); } } void MemoryWrite16(u32 vaddr, u16 value) override { if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) { - memory.Write16(vaddr, value); + m_memory.Write16(vaddr, value); } } void MemoryWrite32(u32 vaddr, u32 value) override { if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) { - memory.Write32(vaddr, value); + m_memory.Write32(vaddr, value); } } void MemoryWrite64(u32 vaddr, u64 value) override { if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) { - memory.Write64(vaddr, value); + m_memory.Write64(vaddr, value); } } bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override { return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive8(vaddr, value, expected); + m_memory.WriteExclusive8(vaddr, value, expected); } bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override { return CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive16(vaddr, value, expected); + m_memory.WriteExclusive16(vaddr, value, expected); } bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override { return CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive32(vaddr, value, expected); + m_memory.WriteExclusive32(vaddr, value, expected); } bool MemoryWriteExclusive64(u32 vaddr, u64 value, u64 expected) override { return CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive64(vaddr, value, expected); + m_memory.WriteExclusive64(vaddr, value, expected); } void InterpreterFallback(u32 pc, std::size_t num_instructions) override { - parent.LogBacktrace(); + m_parent.LogBacktrace(m_process); LOG_ERROR(Core_ARM, "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc, - num_instructions, memory.Read32(pc)); + num_instructions, m_memory.Read32(pc)); } void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override { @@ -108,73 +96,64 @@ public: ReturnException(pc, PrefetchAbort); return; default: - if (debugger_enabled) { + if (m_debugger_enabled) { ReturnException(pc, InstructionBreakpoint); return; } - parent.LogBacktrace(); + m_parent.LogBacktrace(m_process); LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X}, thumb = {})", - exception, pc, memory.Read32(pc), parent.IsInThumbMode()); + exception, pc, m_memory.Read32(pc), m_parent.IsInThumbMode()); } } void CallSVC(u32 swi) override { - parent.svc_swi = swi; - parent.jit.load()->HaltExecution(SupervisorCall); + m_parent.m_svc_swi = swi; + m_parent.m_jit->HaltExecution(SupervisorCall); } void AddTicks(u64 ticks) override { - if (parent.uses_wall_clock) { - return; - } + ASSERT_MSG(!m_parent.m_uses_wall_clock, "Dynarmic ticking disabled"); // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a // rough approximation of the amount of executed ticks in the system, it may be thrown off // if not all cores are doing a similar amount of work. Instead of doing this, we should // device a way so that timing is consistent across all cores without increasing the ticks 4 // times. - u64 amortized_ticks = - (ticks - num_interpreted_instructions) / Core::Hardware::NUM_CPU_CORES; + u64 amortized_ticks = ticks / Core::Hardware::NUM_CPU_CORES; // Always execute at least one tick. amortized_ticks = std::max<u64>(amortized_ticks, 1); - parent.system.CoreTiming().AddTicks(amortized_ticks); - num_interpreted_instructions = 0; + m_parent.m_system.CoreTiming().AddTicks(amortized_ticks); } u64 GetTicksRemaining() override { - if (parent.uses_wall_clock) { - if (!IsInterrupted()) { - return minimum_run_cycles; - } - return 0U; - } + ASSERT_MSG(!m_parent.m_uses_wall_clock, "Dynarmic ticking disabled"); - return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0); + return std::max<s64>(m_parent.m_system.CoreTiming().GetDowncount(), 0); } bool CheckMemoryAccess(u64 addr, u64 size, Kernel::DebugWatchpointType type) { - if (!check_memory_access) { + if (!m_check_memory_access) { return true; } - if (!memory.IsValidVirtualAddressRange(addr, size)) { + if (!m_memory.IsValidVirtualAddressRange(addr, size)) { LOG_CRITICAL(Core_ARM, "Stopping execution due to unmapped memory access at {:#x}", addr); - parent.jit.load()->HaltExecution(PrefetchAbort); + m_parent.m_jit->HaltExecution(PrefetchAbort); return false; } - if (!debugger_enabled) { + if (!m_debugger_enabled) { return true; } - const auto match{parent.MatchingWatchpoint(addr, size, type)}; + const auto match{m_parent.MatchingWatchpoint(addr, size, type)}; if (match) { - parent.halted_watchpoint = match; - parent.jit.load()->HaltExecution(DataAbort); + m_parent.m_halted_watchpoint = match; + m_parent.m_jit->HaltExecution(DataAbort); return false; } @@ -182,32 +161,31 @@ public: } void ReturnException(u32 pc, Dynarmic::HaltReason hr) { - parent.SaveContext(parent.breakpoint_context); - parent.breakpoint_context.cpu_registers[15] = pc; - parent.jit.load()->HaltExecution(hr); - } - - bool IsInterrupted() { - return parent.system.Kernel().PhysicalCore(parent.core_index).IsInterrupted(); + m_parent.GetContext(m_parent.m_breakpoint_context); + m_parent.m_breakpoint_context.pc = pc; + m_parent.m_breakpoint_context.r[15] = pc; + m_parent.m_jit->HaltExecution(hr); } - ARM_Dynarmic_32& parent; - Core::Memory::Memory& memory; - std::size_t num_interpreted_instructions{}; - const bool debugger_enabled{}; - const bool check_memory_access{}; - static constexpr u64 minimum_run_cycles = 10000U; + ArmDynarmic32& m_parent; + Core::Memory::Memory& m_memory; + const Kernel::KProcess* m_process{}; + const bool m_debugger_enabled{}; + const bool m_check_memory_access{}; + static constexpr u64 MinimumRunCycles = 10000U; }; -std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable* page_table) const { +std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* page_table) const { Dynarmic::A32::UserConfig config; - config.callbacks = cb.get(); - config.coprocessors[15] = cp15; + config.callbacks = m_cb.get(); + config.coprocessors[15] = m_cp15; config.define_unpredictable_behaviour = true; - static constexpr std::size_t YUZU_PAGEBITS = 12; - static constexpr std::size_t NUM_PAGE_TABLE_ENTRIES = 1 << (32 - YUZU_PAGEBITS); + if (page_table) { - config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>( + constexpr size_t PageBits = 12; + constexpr size_t NumPageTableEntries = 1 << (32 - PageBits); + + config.page_table = reinterpret_cast<std::array<std::uint8_t*, NumPageTableEntries>*>( page_table->pointers.data()); config.absolute_offset_page_table = true; config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS; @@ -221,12 +199,12 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable* } // Multi-process state - config.processor_id = core_index; - config.global_monitor = &exclusive_monitor.monitor; + config.processor_id = m_core_index; + config.global_monitor = &m_exclusive_monitor.monitor; // Timing - config.wall_clock_cntpct = uses_wall_clock; - config.enable_cycle_counting = true; + config.wall_clock_cntpct = m_uses_wall_clock; + config.enable_cycle_counting = !m_uses_wall_clock; // Code cache size #ifdef ARCHITECTURE_arm64 @@ -236,7 +214,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable* #endif // Allow memory fault handling to work - if (system.DebuggerEnabled()) { + if (m_system.DebuggerEnabled()) { config.check_halt_on_memory_access = true; } @@ -325,137 +303,140 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable* return std::make_unique<Dynarmic::A32::Jit>(config); } -HaltReason ARM_Dynarmic_32::RunJit() { - return TranslateHaltReason(jit.load()->Run()); +static std::pair<u32, u32> FpscrToFpsrFpcr(u32 fpscr) { + // FPSCR bits [31:27] are mapped to FPSR[31:27]. + // FPSCR bit [7] is mapped to FPSR[7]. + // FPSCR bits [4:0] are mapped to FPSR[4:0]. + const u32 nzcv = fpscr & 0xf8000000; + const u32 idc = fpscr & 0x80; + const u32 fiq = fpscr & 0x1f; + const u32 fpsr = nzcv | idc | fiq; + + // FPSCR bits [26:15] are mapped to FPCR[26:15]. + // FPSCR bits [12:8] are mapped to FPCR[12:8]. + const u32 round = fpscr & 0x7ff8000; + const u32 trap = fpscr & 0x1f00; + const u32 fpcr = round | trap; + + return {fpsr, fpcr}; } -HaltReason ARM_Dynarmic_32::StepJit() { - return TranslateHaltReason(jit.load()->Step()); +static u32 FpsrFpcrToFpscr(u64 fpsr, u64 fpcr) { + auto [s, c] = FpscrToFpsrFpcr(static_cast<u32>(fpsr | fpcr)); + return s | c; } -u32 ARM_Dynarmic_32::GetSvcNumber() const { - return svc_swi; +bool ArmDynarmic32::IsInThumbMode() const { + return (m_jit->Cpsr() & 0x20) != 0; } -const Kernel::DebugWatchpoint* ARM_Dynarmic_32::HaltedWatchpoint() const { - return halted_watchpoint; +HaltReason ArmDynarmic32::RunThread(Kernel::KThread* thread) { + m_jit->ClearExclusiveState(); + return TranslateHaltReason(m_jit->Run()); } -void ARM_Dynarmic_32::RewindBreakpointInstruction() { - LoadContext(breakpoint_context); +HaltReason ArmDynarmic32::StepThread(Kernel::KThread* thread) { + m_jit->ClearExclusiveState(); + return TranslateHaltReason(m_jit->Step()); } -ARM_Dynarmic_32::ARM_Dynarmic_32(System& system_, bool uses_wall_clock_, - DynarmicExclusiveMonitor& exclusive_monitor_, - std::size_t core_index_) - : ARM_Interface{system_, uses_wall_clock_}, cb(std::make_unique<DynarmicCallbacks32>(*this)), - cp15(std::make_shared<DynarmicCP15>(*this)), core_index{core_index_}, - exclusive_monitor{exclusive_monitor_}, null_jit{MakeJit(nullptr)}, jit{null_jit.get()} {} +u32 ArmDynarmic32::GetSvcNumber() const { + return m_svc_swi; +} -ARM_Dynarmic_32::~ARM_Dynarmic_32() = default; +void ArmDynarmic32::GetSvcArguments(std::span<uint64_t, 8> args) const { + Dynarmic::A32::Jit& j = *m_jit; + auto& gpr = j.Regs(); -void ARM_Dynarmic_32::SetPC(u64 pc) { - jit.load()->Regs()[15] = static_cast<u32>(pc); + for (size_t i = 0; i < 8; i++) { + args[i] = gpr[i]; + } } -u64 ARM_Dynarmic_32::GetPC() const { - return jit.load()->Regs()[15]; -} +void ArmDynarmic32::SetSvcArguments(std::span<const uint64_t, 8> args) { + Dynarmic::A32::Jit& j = *m_jit; + auto& gpr = j.Regs(); -u64 ARM_Dynarmic_32::GetSP() const { - return jit.load()->Regs()[13]; + for (size_t i = 0; i < 8; i++) { + gpr[i] = static_cast<u32>(args[i]); + } } -u64 ARM_Dynarmic_32::GetReg(int index) const { - return jit.load()->Regs()[index]; +const Kernel::DebugWatchpoint* ArmDynarmic32::HaltedWatchpoint() const { + return m_halted_watchpoint; } -void ARM_Dynarmic_32::SetReg(int index, u64 value) { - jit.load()->Regs()[index] = static_cast<u32>(value); +void ArmDynarmic32::RewindBreakpointInstruction() { + this->SetContext(m_breakpoint_context); } -u128 ARM_Dynarmic_32::GetVectorReg(int index) const { - return {}; +ArmDynarmic32::ArmDynarmic32(System& system, bool uses_wall_clock, const Kernel::KProcess* process, + DynarmicExclusiveMonitor& exclusive_monitor, std::size_t core_index) + : ArmInterface{uses_wall_clock}, m_system{system}, m_exclusive_monitor{exclusive_monitor}, + m_cb(std::make_unique<DynarmicCallbacks32>(*this, process)), + m_cp15(std::make_shared<DynarmicCP15>(*this)), m_core_index{core_index} { + auto& page_table_impl = process->GetPageTable().GetBasePageTable().GetImpl(); + m_jit = MakeJit(&page_table_impl); } -void ARM_Dynarmic_32::SetVectorReg(int index, u128 value) {} +ArmDynarmic32::~ArmDynarmic32() = default; -u32 ARM_Dynarmic_32::GetPSTATE() const { - return jit.load()->Cpsr(); +void ArmDynarmic32::SetTpidrroEl0(u64 value) { + m_cp15->uro = static_cast<u32>(value); } -void ARM_Dynarmic_32::SetPSTATE(u32 cpsr) { - jit.load()->SetCpsr(cpsr); -} +void ArmDynarmic32::GetContext(Kernel::Svc::ThreadContext& ctx) const { + Dynarmic::A32::Jit& j = *m_jit; + auto& gpr = j.Regs(); + auto& fpr = j.ExtRegs(); -u64 ARM_Dynarmic_32::GetTlsAddress() const { - return cp15->uro; -} + for (size_t i = 0; i < 16; i++) { + ctx.r[i] = gpr[i]; + } -void ARM_Dynarmic_32::SetTlsAddress(u64 address) { - cp15->uro = static_cast<u32>(address); -} + ctx.fp = gpr[11]; + ctx.sp = gpr[13]; + ctx.lr = gpr[14]; + ctx.pc = gpr[15]; + ctx.pstate = j.Cpsr(); -u64 ARM_Dynarmic_32::GetTPIDR_EL0() const { - return cp15->uprw; -} + static_assert(sizeof(fpr) <= sizeof(ctx.v)); + std::memcpy(ctx.v.data(), &fpr, sizeof(fpr)); -void ARM_Dynarmic_32::SetTPIDR_EL0(u64 value) { - cp15->uprw = static_cast<u32>(value); + auto [fpsr, fpcr] = FpscrToFpsrFpcr(j.Fpscr()); + ctx.fpcr = fpcr; + ctx.fpsr = fpsr; + ctx.tpidr = m_cp15->uprw; } -void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) const { - Dynarmic::A32::Jit* j = jit.load(); - ctx.cpu_registers = j->Regs(); - ctx.extension_registers = j->ExtRegs(); - ctx.cpsr = j->Cpsr(); - ctx.fpscr = j->Fpscr(); -} +void ArmDynarmic32::SetContext(const Kernel::Svc::ThreadContext& ctx) { + Dynarmic::A32::Jit& j = *m_jit; + auto& gpr = j.Regs(); + auto& fpr = j.ExtRegs(); -void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) { - Dynarmic::A32::Jit* j = jit.load(); - j->Regs() = ctx.cpu_registers; - j->ExtRegs() = ctx.extension_registers; - j->SetCpsr(ctx.cpsr); - j->SetFpscr(ctx.fpscr); -} + for (size_t i = 0; i < 16; i++) { + gpr[i] = static_cast<u32>(ctx.r[i]); + } -void ARM_Dynarmic_32::SignalInterrupt() { - jit.load()->HaltExecution(BreakLoop); -} + j.SetCpsr(ctx.pstate); -void ARM_Dynarmic_32::ClearInterrupt() { - jit.load()->ClearHalt(BreakLoop); -} + static_assert(sizeof(fpr) <= sizeof(ctx.v)); + std::memcpy(&fpr, ctx.v.data(), sizeof(fpr)); -void ARM_Dynarmic_32::ClearInstructionCache() { - jit.load()->ClearCache(); + j.SetFpscr(FpsrFpcrToFpscr(ctx.fpsr, ctx.fpcr)); + m_cp15->uprw = static_cast<u32>(ctx.tpidr); } -void ARM_Dynarmic_32::InvalidateCacheRange(u64 addr, std::size_t size) { - jit.load()->InvalidateCacheRange(static_cast<u32>(addr), size); +void ArmDynarmic32::SignalInterrupt(Kernel::KThread* thread) { + m_jit->HaltExecution(BreakLoop); } -void ARM_Dynarmic_32::ClearExclusiveState() { - jit.load()->ClearExclusiveState(); +void ArmDynarmic32::ClearInstructionCache() { + m_jit->ClearCache(); } -void ARM_Dynarmic_32::PageTableChanged(Common::PageTable& page_table, - std::size_t new_address_space_size_in_bits) { - ThreadContext32 ctx{}; - SaveContext(ctx); - - auto key = std::make_pair(&page_table, new_address_space_size_in_bits); - auto iter = jit_cache.find(key); - if (iter != jit_cache.end()) { - jit.store(iter->second.get()); - LoadContext(ctx); - return; - } - std::shared_ptr new_jit = MakeJit(&page_table); - jit.store(new_jit.get()); - LoadContext(ctx); - jit_cache.emplace(key, std::move(new_jit)); +void ArmDynarmic32::InvalidateCacheRange(u64 addr, std::size_t size) { + m_jit->InvalidateCacheRange(static_cast<u32>(addr), size); } } // namespace Core diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.h b/src/core/arm/dynarmic/arm_dynarmic_32.h index 92fb3f836..185ac7cbf 100644 --- a/src/core/arm/dynarmic/arm_dynarmic_32.h +++ b/src/core/arm/dynarmic/arm_dynarmic_32.h @@ -3,14 +3,8 @@ #pragma once -#include <atomic> -#include <memory> -#include <unordered_map> - #include <dynarmic/interface/A32/a32.h> -#include <dynarmic/interface/A64/a64.h> -#include "common/common_types.h" -#include "common/hash.h" + #include "core/arm/arm_interface.h" #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h" @@ -20,89 +14,63 @@ class Memory; namespace Core { -class CPUInterruptHandler; class DynarmicCallbacks32; class DynarmicCP15; -class DynarmicExclusiveMonitor; class System; -class ARM_Dynarmic_32 final : public ARM_Interface { +class ArmDynarmic32 final : public ArmInterface { public: - ARM_Dynarmic_32(System& system_, bool uses_wall_clock_, - DynarmicExclusiveMonitor& exclusive_monitor_, std::size_t core_index_); - ~ARM_Dynarmic_32() override; - - void SetPC(u64 pc) override; - u64 GetPC() const override; - u64 GetSP() const override; - u64 GetReg(int index) const override; - void SetReg(int index, u64 value) override; - u128 GetVectorReg(int index) const override; - void SetVectorReg(int index, u128 value) override; - u32 GetPSTATE() const override; - void SetPSTATE(u32 pstate) override; - u64 GetTlsAddress() const override; - void SetTlsAddress(u64 address) override; - void SetTPIDR_EL0(u64 value) override; - u64 GetTPIDR_EL0() const override; - - bool IsInThumbMode() const { - return (GetPSTATE() & 0x20) != 0; - } + ArmDynarmic32(System& system, bool uses_wall_clock, const Kernel::KProcess* process, + DynarmicExclusiveMonitor& exclusive_monitor, std::size_t core_index); + ~ArmDynarmic32() override; Architecture GetArchitecture() const override { - return Architecture::Aarch32; + return Architecture::AArch32; } - void SaveContext(ThreadContext32& ctx) const override; - void SaveContext(ThreadContext64& ctx) const override {} - void LoadContext(const ThreadContext32& ctx) override; - void LoadContext(const ThreadContext64& ctx) override {} - void SignalInterrupt() override; - void ClearInterrupt() override; - void ClearExclusiveState() override; + bool IsInThumbMode() const; + + HaltReason RunThread(Kernel::KThread* thread) override; + HaltReason StepThread(Kernel::KThread* thread) override; + + void GetContext(Kernel::Svc::ThreadContext& ctx) const override; + void SetContext(const Kernel::Svc::ThreadContext& ctx) override; + void SetTpidrroEl0(u64 value) override; + + void GetSvcArguments(std::span<uint64_t, 8> args) const override; + void SetSvcArguments(std::span<const uint64_t, 8> args) override; + u32 GetSvcNumber() const override; + void SignalInterrupt(Kernel::KThread* thread) override; void ClearInstructionCache() override; void InvalidateCacheRange(u64 addr, std::size_t size) override; - void PageTableChanged(Common::PageTable& new_page_table, - std::size_t new_address_space_size_in_bits) override; protected: - HaltReason RunJit() override; - HaltReason StepJit() override; - u32 GetSvcNumber() const override; const Kernel::DebugWatchpoint* HaltedWatchpoint() const override; void RewindBreakpointInstruction() override; private: - std::shared_ptr<Dynarmic::A32::Jit> MakeJit(Common::PageTable* page_table) const; - - static std::vector<BacktraceEntry> GetBacktrace(Core::System& system, u64 fp, u64 lr, u64 pc); - - using JitCacheKey = std::pair<Common::PageTable*, std::size_t>; - using JitCacheType = - std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A32::Jit>, Common::PairHash>; + System& m_system; + DynarmicExclusiveMonitor& m_exclusive_monitor; +private: friend class DynarmicCallbacks32; friend class DynarmicCP15; - std::unique_ptr<DynarmicCallbacks32> cb; - JitCacheType jit_cache; - std::shared_ptr<DynarmicCP15> cp15; - std::size_t core_index; - DynarmicExclusiveMonitor& exclusive_monitor; + std::shared_ptr<Dynarmic::A32::Jit> MakeJit(Common::PageTable* page_table) const; - std::shared_ptr<Dynarmic::A32::Jit> null_jit; + std::unique_ptr<DynarmicCallbacks32> m_cb{}; + std::shared_ptr<DynarmicCP15> m_cp15{}; + std::size_t m_core_index{}; - // A raw pointer here is fine; we never delete Jit instances. - std::atomic<Dynarmic::A32::Jit*> jit; + std::shared_ptr<Dynarmic::A32::Jit> m_jit{}; // SVC callback - u32 svc_swi{}; + u32 m_svc_swi{}; // Watchpoint info - const Kernel::DebugWatchpoint* halted_watchpoint; - ThreadContext32 breakpoint_context; + const Kernel::DebugWatchpoint* m_halted_watchpoint{}; + Kernel::Svc::ThreadContext m_breakpoint_context{}; }; } // namespace Core diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.cpp b/src/core/arm/dynarmic/arm_dynarmic_64.cpp index 2e3674b6d..dff14756e 100644 --- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp +++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp @@ -1,25 +1,12 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <cinttypes> -#include <memory> -#include <dynarmic/interface/A64/a64.h> -#include <dynarmic/interface/A64/config.h> -#include "common/assert.h" -#include "common/literals.h" -#include "common/logging/log.h" -#include "common/page_table.h" #include "common/settings.h" #include "core/arm/dynarmic/arm_dynarmic.h" #include "core/arm/dynarmic/arm_dynarmic_64.h" #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h" -#include "core/core.h" #include "core/core_timing.h" -#include "core/debugger/debugger.h" -#include "core/hardware_properties.h" #include "core/hle/kernel/k_process.h" -#include "core/hle/kernel/svc.h" -#include "core/memory.h" namespace Core { @@ -28,92 +15,92 @@ using namespace Common::Literals; class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks { public: - explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_) - : parent{parent_}, memory(parent.system.ApplicationMemory()), - debugger_enabled{parent.system.DebuggerEnabled()}, - check_memory_access{debugger_enabled || - !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {} + explicit DynarmicCallbacks64(ArmDynarmic64& parent, const Kernel::KProcess* process) + : m_parent{parent}, m_memory(process->GetMemory()), + m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()}, + m_check_memory_access{m_debugger_enabled || + !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {} u8 MemoryRead8(u64 vaddr) override { CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read); - return memory.Read8(vaddr); + return m_memory.Read8(vaddr); } u16 MemoryRead16(u64 vaddr) override { CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read); - return memory.Read16(vaddr); + return m_memory.Read16(vaddr); } u32 MemoryRead32(u64 vaddr) override { CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read); - return memory.Read32(vaddr); + return m_memory.Read32(vaddr); } u64 MemoryRead64(u64 vaddr) override { CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read); - return memory.Read64(vaddr); + return m_memory.Read64(vaddr); } Vector MemoryRead128(u64 vaddr) override { CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Read); - return {memory.Read64(vaddr), memory.Read64(vaddr + 8)}; + return {m_memory.Read64(vaddr), m_memory.Read64(vaddr + 8)}; } std::optional<u32> MemoryReadCode(u64 vaddr) override { - if (!memory.IsValidVirtualAddressRange(vaddr, sizeof(u32))) { + if (!m_memory.IsValidVirtualAddressRange(vaddr, sizeof(u32))) { return std::nullopt; } - return memory.Read32(vaddr); + return m_memory.Read32(vaddr); } void MemoryWrite8(u64 vaddr, u8 value) override { if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) { - memory.Write8(vaddr, value); + m_memory.Write8(vaddr, value); } } void MemoryWrite16(u64 vaddr, u16 value) override { if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) { - memory.Write16(vaddr, value); + m_memory.Write16(vaddr, value); } } void MemoryWrite32(u64 vaddr, u32 value) override { if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) { - memory.Write32(vaddr, value); + m_memory.Write32(vaddr, value); } } void MemoryWrite64(u64 vaddr, u64 value) override { if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) { - memory.Write64(vaddr, value); + m_memory.Write64(vaddr, value); } } void MemoryWrite128(u64 vaddr, Vector value) override { if (CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Write)) { - memory.Write64(vaddr, value[0]); - memory.Write64(vaddr + 8, value[1]); + m_memory.Write64(vaddr, value[0]); + m_memory.Write64(vaddr + 8, value[1]); } } bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override { return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive8(vaddr, value, expected); + m_memory.WriteExclusive8(vaddr, value, expected); } bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override { return CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive16(vaddr, value, expected); + m_memory.WriteExclusive16(vaddr, value, expected); } bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, std::uint32_t expected) override { return CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive32(vaddr, value, expected); + m_memory.WriteExclusive32(vaddr, value, expected); } bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, std::uint64_t expected) override { return CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive64(vaddr, value, expected); + m_memory.WriteExclusive64(vaddr, value, expected); } bool MemoryWriteExclusive128(u64 vaddr, Vector value, Vector expected) override { return CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Write) && - memory.WriteExclusive128(vaddr, value, expected); + m_memory.WriteExclusive128(vaddr, value, expected); } void InterpreterFallback(u64 pc, std::size_t num_instructions) override { - parent.LogBacktrace(); + m_parent.LogBacktrace(m_process); LOG_ERROR(Core_ARM, "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc, - num_instructions, memory.Read32(pc)); + num_instructions, m_memory.Read32(pc)); ReturnException(pc, PrefetchAbort); } @@ -124,11 +111,11 @@ public: static constexpr u64 ICACHE_LINE_SIZE = 64; const u64 cache_line_start = value & ~(ICACHE_LINE_SIZE - 1); - parent.system.InvalidateCpuInstructionCacheRange(cache_line_start, ICACHE_LINE_SIZE); + m_parent.InvalidateCacheRange(cache_line_start, ICACHE_LINE_SIZE); break; } case Dynarmic::A64::InstructionCacheOperation::InvalidateAllToPoU: - parent.system.InvalidateCpuInstructionCaches(); + m_parent.ClearInstructionCache(); break; case Dynarmic::A64::InstructionCacheOperation::InvalidateAllToPoUInnerSharable: default: @@ -136,7 +123,7 @@ public: break; } - parent.jit.load()->HaltExecution(Dynarmic::HaltReason::CacheInvalidation); + m_parent.m_jit->HaltExecution(Dynarmic::HaltReason::CacheInvalidation); } void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override { @@ -152,26 +139,24 @@ public: ReturnException(pc, PrefetchAbort); return; default: - if (debugger_enabled) { + if (m_debugger_enabled) { ReturnException(pc, InstructionBreakpoint); return; } - parent.LogBacktrace(); + m_parent.LogBacktrace(m_process); LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})", - static_cast<std::size_t>(exception), pc, memory.Read32(pc)); + static_cast<std::size_t>(exception), pc, m_memory.Read32(pc)); } } - void CallSVC(u32 swi) override { - parent.svc_swi = swi; - parent.jit.load()->HaltExecution(SupervisorCall); + void CallSVC(u32 svc) override { + m_parent.m_svc = svc; + m_parent.m_jit->HaltExecution(SupervisorCall); } void AddTicks(u64 ticks) override { - if (parent.uses_wall_clock) { - return; - } + ASSERT_MSG(!m_parent.m_uses_wall_clock, "Dynarmic ticking disabled"); // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a // rough approximation of the amount of executed ticks in the system, it may be thrown off @@ -182,44 +167,39 @@ public: // Always execute at least one tick. amortized_ticks = std::max<u64>(amortized_ticks, 1); - parent.system.CoreTiming().AddTicks(amortized_ticks); + m_parent.m_system.CoreTiming().AddTicks(amortized_ticks); } u64 GetTicksRemaining() override { - if (parent.uses_wall_clock) { - if (!IsInterrupted()) { - return minimum_run_cycles; - } - return 0U; - } + ASSERT_MSG(!m_parent.m_uses_wall_clock, "Dynarmic ticking disabled"); - return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0); + return std::max<s64>(m_parent.m_system.CoreTiming().GetDowncount(), 0); } u64 GetCNTPCT() override { - return parent.system.CoreTiming().GetClockTicks(); + return m_parent.m_system.CoreTiming().GetClockTicks(); } bool CheckMemoryAccess(u64 addr, u64 size, Kernel::DebugWatchpointType type) { - if (!check_memory_access) { + if (!m_check_memory_access) { return true; } - if (!memory.IsValidVirtualAddressRange(addr, size)) { + if (!m_memory.IsValidVirtualAddressRange(addr, size)) { LOG_CRITICAL(Core_ARM, "Stopping execution due to unmapped memory access at {:#x}", addr); - parent.jit.load()->HaltExecution(PrefetchAbort); + m_parent.m_jit->HaltExecution(PrefetchAbort); return false; } - if (!debugger_enabled) { + if (!m_debugger_enabled) { return true; } - const auto match{parent.MatchingWatchpoint(addr, size, type)}; + const auto match{m_parent.MatchingWatchpoint(addr, size, type)}; if (match) { - parent.halted_watchpoint = match; - parent.jit.load()->HaltExecution(DataAbort); + m_parent.m_halted_watchpoint = match; + m_parent.m_jit->HaltExecution(DataAbort); return false; } @@ -227,30 +207,27 @@ public: } void ReturnException(u64 pc, Dynarmic::HaltReason hr) { - parent.SaveContext(parent.breakpoint_context); - parent.breakpoint_context.pc = pc; - parent.jit.load()->HaltExecution(hr); + m_parent.GetContext(m_parent.m_breakpoint_context); + m_parent.m_breakpoint_context.pc = pc; + m_parent.m_jit->HaltExecution(hr); } - bool IsInterrupted() { - return parent.system.Kernel().PhysicalCore(parent.core_index).IsInterrupted(); - } - - ARM_Dynarmic_64& parent; - Core::Memory::Memory& memory; - u64 tpidrro_el0 = 0; - u64 tpidr_el0 = 0; - const bool debugger_enabled{}; - const bool check_memory_access{}; - static constexpr u64 minimum_run_cycles = 10000U; + ArmDynarmic64& m_parent; + Core::Memory::Memory& m_memory; + u64 m_tpidrro_el0{}; + u64 m_tpidr_el0{}; + const Kernel::KProcess* m_process{}; + const bool m_debugger_enabled{}; + const bool m_check_memory_access{}; + static constexpr u64 MinimumRunCycles = 10000U; }; -std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable* page_table, - std::size_t address_space_bits) const { +std::shared_ptr<Dynarmic::A64::Jit> ArmDynarmic64::MakeJit(Common::PageTable* page_table, + std::size_t address_space_bits) const { Dynarmic::A64::UserConfig config; // Callbacks - config.callbacks = cb.get(); + config.callbacks = m_cb.get(); // Memory if (page_table) { @@ -271,12 +248,12 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable* } // Multi-process state - config.processor_id = core_index; - config.global_monitor = &exclusive_monitor.monitor; + config.processor_id = m_core_index; + config.global_monitor = &m_exclusive_monitor.monitor; // System registers - config.tpidrro_el0 = &cb->tpidrro_el0; - config.tpidr_el0 = &cb->tpidr_el0; + config.tpidrro_el0 = &m_cb->m_tpidrro_el0; + config.tpidr_el0 = &m_cb->m_tpidr_el0; config.dczid_el0 = 4; config.ctr_el0 = 0x8444c004; config.cntfrq_el0 = Hardware::CNTFREQ; @@ -285,8 +262,8 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable* config.define_unpredictable_behaviour = true; // Timing - config.wall_clock_cntpct = uses_wall_clock; - config.enable_cycle_counting = true; + config.wall_clock_cntpct = m_uses_wall_clock; + config.enable_cycle_counting = !m_uses_wall_clock; // Code cache size #ifdef ARCHITECTURE_arm64 @@ -296,7 +273,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable* #endif // Allow memory fault handling to work - if (system.DebuggerEnabled()) { + if (m_system.DebuggerEnabled()) { config.check_halt_on_memory_access = true; } @@ -384,147 +361,112 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable* return std::make_shared<Dynarmic::A64::Jit>(config); } -HaltReason ARM_Dynarmic_64::RunJit() { - return TranslateHaltReason(jit.load()->Run()); -} - -HaltReason ARM_Dynarmic_64::StepJit() { - return TranslateHaltReason(jit.load()->Step()); -} - -u32 ARM_Dynarmic_64::GetSvcNumber() const { - return svc_swi; -} - -const Kernel::DebugWatchpoint* ARM_Dynarmic_64::HaltedWatchpoint() const { - return halted_watchpoint; -} - -void ARM_Dynarmic_64::RewindBreakpointInstruction() { - LoadContext(breakpoint_context); -} - -ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, bool uses_wall_clock_, - DynarmicExclusiveMonitor& exclusive_monitor_, - std::size_t core_index_) - : ARM_Interface{system_, uses_wall_clock_}, - cb(std::make_unique<DynarmicCallbacks64>(*this)), core_index{core_index_}, - exclusive_monitor{exclusive_monitor_}, null_jit{MakeJit(nullptr, 48)}, jit{null_jit.get()} {} - -ARM_Dynarmic_64::~ARM_Dynarmic_64() = default; - -void ARM_Dynarmic_64::SetPC(u64 pc) { - jit.load()->SetPC(pc); -} - -u64 ARM_Dynarmic_64::GetPC() const { - return jit.load()->GetPC(); +HaltReason ArmDynarmic64::RunThread(Kernel::KThread* thread) { + m_jit->ClearExclusiveState(); + return TranslateHaltReason(m_jit->Run()); } -u64 ARM_Dynarmic_64::GetSP() const { - return jit.load()->GetSP(); +HaltReason ArmDynarmic64::StepThread(Kernel::KThread* thread) { + m_jit->ClearExclusiveState(); + return TranslateHaltReason(m_jit->Step()); } -u64 ARM_Dynarmic_64::GetReg(int index) const { - return jit.load()->GetRegister(index); +u32 ArmDynarmic64::GetSvcNumber() const { + return m_svc; } -void ARM_Dynarmic_64::SetReg(int index, u64 value) { - jit.load()->SetRegister(index, value); -} +void ArmDynarmic64::GetSvcArguments(std::span<uint64_t, 8> args) const { + Dynarmic::A64::Jit& j = *m_jit; -u128 ARM_Dynarmic_64::GetVectorReg(int index) const { - return jit.load()->GetVector(index); + for (size_t i = 0; i < 8; i++) { + args[i] = j.GetRegister(i); + } } -void ARM_Dynarmic_64::SetVectorReg(int index, u128 value) { - jit.load()->SetVector(index, value); -} +void ArmDynarmic64::SetSvcArguments(std::span<const uint64_t, 8> args) { + Dynarmic::A64::Jit& j = *m_jit; -u32 ARM_Dynarmic_64::GetPSTATE() const { - return jit.load()->GetPstate(); + for (size_t i = 0; i < 8; i++) { + j.SetRegister(i, args[i]); + } } -void ARM_Dynarmic_64::SetPSTATE(u32 pstate) { - jit.load()->SetPstate(pstate); +const Kernel::DebugWatchpoint* ArmDynarmic64::HaltedWatchpoint() const { + return m_halted_watchpoint; } -u64 ARM_Dynarmic_64::GetTlsAddress() const { - return cb->tpidrro_el0; +void ArmDynarmic64::RewindBreakpointInstruction() { + this->SetContext(m_breakpoint_context); } -void ARM_Dynarmic_64::SetTlsAddress(u64 address) { - cb->tpidrro_el0 = address; +ArmDynarmic64::ArmDynarmic64(System& system, bool uses_wall_clock, const Kernel::KProcess* process, + DynarmicExclusiveMonitor& exclusive_monitor, std::size_t core_index) + : ArmInterface{uses_wall_clock}, m_system{system}, m_exclusive_monitor{exclusive_monitor}, + m_cb(std::make_unique<DynarmicCallbacks64>(*this, process)), m_core_index{core_index} { + auto& page_table = process->GetPageTable().GetBasePageTable(); + auto& page_table_impl = page_table.GetImpl(); + m_jit = MakeJit(&page_table_impl, page_table.GetAddressSpaceWidth()); } -u64 ARM_Dynarmic_64::GetTPIDR_EL0() const { - return cb->tpidr_el0; -} +ArmDynarmic64::~ArmDynarmic64() = default; -void ARM_Dynarmic_64::SetTPIDR_EL0(u64 value) { - cb->tpidr_el0 = value; +void ArmDynarmic64::SetTpidrroEl0(u64 value) { + m_cb->m_tpidrro_el0 = value; } -void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) const { - Dynarmic::A64::Jit* j = jit.load(); - ctx.cpu_registers = j->GetRegisters(); - ctx.sp = j->GetSP(); - ctx.pc = j->GetPC(); - ctx.pstate = j->GetPstate(); - ctx.vector_registers = j->GetVectors(); - ctx.fpcr = j->GetFpcr(); - ctx.fpsr = j->GetFpsr(); - ctx.tpidr = cb->tpidr_el0; -} +void ArmDynarmic64::GetContext(Kernel::Svc::ThreadContext& ctx) const { + Dynarmic::A64::Jit& j = *m_jit; + auto gpr = j.GetRegisters(); + auto fpr = j.GetVectors(); -void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) { - Dynarmic::A64::Jit* j = jit.load(); - j->SetRegisters(ctx.cpu_registers); - j->SetSP(ctx.sp); - j->SetPC(ctx.pc); - j->SetPstate(ctx.pstate); - j->SetVectors(ctx.vector_registers); - j->SetFpcr(ctx.fpcr); - j->SetFpsr(ctx.fpsr); - SetTPIDR_EL0(ctx.tpidr); + // TODO: this is inconvenient + for (size_t i = 0; i < 29; i++) { + ctx.r[i] = gpr[i]; + } + ctx.fp = gpr[29]; + ctx.lr = gpr[30]; + + ctx.sp = j.GetSP(); + ctx.pc = j.GetPC(); + ctx.pstate = j.GetPstate(); + ctx.v = fpr; + ctx.fpcr = j.GetFpcr(); + ctx.fpsr = j.GetFpsr(); + ctx.tpidr = m_cb->m_tpidr_el0; } -void ARM_Dynarmic_64::SignalInterrupt() { - jit.load()->HaltExecution(BreakLoop); -} +void ArmDynarmic64::SetContext(const Kernel::Svc::ThreadContext& ctx) { + Dynarmic::A64::Jit& j = *m_jit; -void ARM_Dynarmic_64::ClearInterrupt() { - jit.load()->ClearHalt(BreakLoop); -} + // TODO: this is inconvenient + std::array<u64, 31> gpr; -void ARM_Dynarmic_64::ClearInstructionCache() { - jit.load()->ClearCache(); + for (size_t i = 0; i < 29; i++) { + gpr[i] = ctx.r[i]; + } + gpr[29] = ctx.fp; + gpr[30] = ctx.lr; + + j.SetRegisters(gpr); + j.SetSP(ctx.sp); + j.SetPC(ctx.pc); + j.SetPstate(ctx.pstate); + j.SetVectors(ctx.v); + j.SetFpcr(ctx.fpcr); + j.SetFpsr(ctx.fpsr); + m_cb->m_tpidr_el0 = ctx.tpidr; } -void ARM_Dynarmic_64::InvalidateCacheRange(u64 addr, std::size_t size) { - jit.load()->InvalidateCacheRange(addr, size); +void ArmDynarmic64::SignalInterrupt(Kernel::KThread* thread) { + m_jit->HaltExecution(BreakLoop); } -void ARM_Dynarmic_64::ClearExclusiveState() { - jit.load()->ClearExclusiveState(); +void ArmDynarmic64::ClearInstructionCache() { + m_jit->ClearCache(); } -void ARM_Dynarmic_64::PageTableChanged(Common::PageTable& page_table, - std::size_t new_address_space_size_in_bits) { - ThreadContext64 ctx{}; - SaveContext(ctx); - - auto key = std::make_pair(&page_table, new_address_space_size_in_bits); - auto iter = jit_cache.find(key); - if (iter != jit_cache.end()) { - jit.store(iter->second.get()); - LoadContext(ctx); - return; - } - std::shared_ptr new_jit = MakeJit(&page_table, new_address_space_size_in_bits); - jit.store(new_jit.get()); - LoadContext(ctx); - jit_cache.emplace(key, std::move(new_jit)); +void ArmDynarmic64::InvalidateCacheRange(u64 addr, std::size_t size) { + m_jit->InvalidateCacheRange(addr, size); } } // namespace Core diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.h b/src/core/arm/dynarmic/arm_dynarmic_64.h index 2b88a08e2..4f3dd026f 100644 --- a/src/core/arm/dynarmic/arm_dynarmic_64.h +++ b/src/core/arm/dynarmic/arm_dynarmic_64.h @@ -23,76 +23,55 @@ class DynarmicCallbacks64; class DynarmicExclusiveMonitor; class System; -class ARM_Dynarmic_64 final : public ARM_Interface { +class ArmDynarmic64 final : public ArmInterface { public: - ARM_Dynarmic_64(System& system_, bool uses_wall_clock_, - DynarmicExclusiveMonitor& exclusive_monitor_, std::size_t core_index_); - ~ARM_Dynarmic_64() override; - - void SetPC(u64 pc) override; - u64 GetPC() const override; - u64 GetSP() const override; - u64 GetReg(int index) const override; - void SetReg(int index, u64 value) override; - u128 GetVectorReg(int index) const override; - void SetVectorReg(int index, u128 value) override; - u32 GetPSTATE() const override; - void SetPSTATE(u32 pstate) override; - u64 GetTlsAddress() const override; - void SetTlsAddress(u64 address) override; - void SetTPIDR_EL0(u64 value) override; - u64 GetTPIDR_EL0() const override; + ArmDynarmic64(System& system, bool uses_wall_clock, const Kernel::KProcess* process, + DynarmicExclusiveMonitor& exclusive_monitor, std::size_t core_index); + ~ArmDynarmic64() override; Architecture GetArchitecture() const override { - return Architecture::Aarch64; + return Architecture::AArch64; } - void SaveContext(ThreadContext32& ctx) const override {} - void SaveContext(ThreadContext64& ctx) const override; - void LoadContext(const ThreadContext32& ctx) override {} - void LoadContext(const ThreadContext64& ctx) override; - void SignalInterrupt() override; - void ClearInterrupt() override; - void ClearExclusiveState() override; + HaltReason RunThread(Kernel::KThread* thread) override; + HaltReason StepThread(Kernel::KThread* thread) override; + void GetContext(Kernel::Svc::ThreadContext& ctx) const override; + void SetContext(const Kernel::Svc::ThreadContext& ctx) override; + void SetTpidrroEl0(u64 value) override; + + void GetSvcArguments(std::span<uint64_t, 8> args) const override; + void SetSvcArguments(std::span<const uint64_t, 8> args) override; + u32 GetSvcNumber() const override; + + void SignalInterrupt(Kernel::KThread* thread) override; void ClearInstructionCache() override; void InvalidateCacheRange(u64 addr, std::size_t size) override; - void PageTableChanged(Common::PageTable& new_page_table, - std::size_t new_address_space_size_in_bits) override; protected: - HaltReason RunJit() override; - HaltReason StepJit() override; - u32 GetSvcNumber() const override; const Kernel::DebugWatchpoint* HaltedWatchpoint() const override; void RewindBreakpointInstruction() override; private: - std::shared_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable* page_table, - std::size_t address_space_bits) const; - - using JitCacheKey = std::pair<Common::PageTable*, std::size_t>; - using JitCacheType = - std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A64::Jit>, Common::PairHash>; + System& m_system; + DynarmicExclusiveMonitor& m_exclusive_monitor; +private: friend class DynarmicCallbacks64; - std::unique_ptr<DynarmicCallbacks64> cb; - JitCacheType jit_cache; - - std::size_t core_index; - DynarmicExclusiveMonitor& exclusive_monitor; - std::shared_ptr<Dynarmic::A64::Jit> null_jit; + std::shared_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable* page_table, + std::size_t address_space_bits) const; + std::unique_ptr<DynarmicCallbacks64> m_cb{}; + std::size_t m_core_index{}; - // A raw pointer here is fine; we never delete Jit instances. - std::atomic<Dynarmic::A64::Jit*> jit; + std::shared_ptr<Dynarmic::A64::Jit> m_jit{}; // SVC callback - u32 svc_swi{}; + u32 m_svc{}; - // Breakpoint info - const Kernel::DebugWatchpoint* halted_watchpoint; - ThreadContext64 breakpoint_context; + // Watchpoint info + const Kernel::DebugWatchpoint* m_halted_watchpoint{}; + Kernel::Svc::ThreadContext m_breakpoint_context{}; }; } // namespace Core diff --git a/src/core/arm/dynarmic/dynarmic_cp15.cpp b/src/core/arm/dynarmic/dynarmic_cp15.cpp index 92c548db0..f3eee0d42 100644 --- a/src/core/arm/dynarmic/dynarmic_cp15.cpp +++ b/src/core/arm/dynarmic/dynarmic_cp15.cpp @@ -124,8 +124,8 @@ CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc if (!two && opc == 0 && CRm == CoprocReg::C14) { // CNTPCT const auto callback = [](void* arg, u32, u32) -> u64 { - const auto& parent_arg = *static_cast<ARM_Dynarmic_32*>(arg); - return parent_arg.system.CoreTiming().GetClockTicks(); + const auto& parent_arg = *static_cast<ArmDynarmic32*>(arg); + return parent_arg.m_system.CoreTiming().GetClockTicks(); }; return Callback{callback, &parent}; } diff --git a/src/core/arm/dynarmic/dynarmic_cp15.h b/src/core/arm/dynarmic/dynarmic_cp15.h index d90b3e568..f3d96b0d8 100644 --- a/src/core/arm/dynarmic/dynarmic_cp15.h +++ b/src/core/arm/dynarmic/dynarmic_cp15.h @@ -10,13 +10,13 @@ namespace Core { -class ARM_Dynarmic_32; +class ArmDynarmic32; class DynarmicCP15 final : public Dynarmic::A32::Coprocessor { public: using CoprocReg = Dynarmic::A32::CoprocReg; - explicit DynarmicCP15(ARM_Dynarmic_32& parent_) : parent{parent_} {} + explicit DynarmicCP15(ArmDynarmic32& parent_) : parent{parent_} {} std::optional<Callback> CompileInternalOperation(bool two, unsigned opc1, CoprocReg CRd, CoprocReg CRn, CoprocReg CRm, @@ -32,11 +32,11 @@ public: std::optional<Callback> CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd, std::optional<u8> option) override; - ARM_Dynarmic_32& parent; + ArmDynarmic32& parent; u32 uprw = 0; u32 uro = 0; - friend class ARM_Dynarmic_32; + friend class ArmDynarmic32; }; } // namespace Core diff --git a/src/core/arm/dynarmic/dynarmic_exclusive_monitor.h b/src/core/arm/dynarmic/dynarmic_exclusive_monitor.h index fbfcd8d95..c4f22ec89 100644 --- a/src/core/arm/dynarmic/dynarmic_exclusive_monitor.h +++ b/src/core/arm/dynarmic/dynarmic_exclusive_monitor.h @@ -14,8 +14,8 @@ class Memory; namespace Core { -class ARM_Dynarmic_32; -class ARM_Dynarmic_64; +class ArmDynarmic32; +class ArmDynarmic64; class DynarmicExclusiveMonitor final : public ExclusiveMonitor { public: @@ -36,8 +36,8 @@ public: bool ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) override; private: - friend class ARM_Dynarmic_32; - friend class ARM_Dynarmic_64; + friend class ArmDynarmic32; + friend class ArmDynarmic64; Dynarmic::ExclusiveMonitor monitor; Core::Memory::Memory& memory; }; diff --git a/src/core/arm/nce/arm_nce.cpp b/src/core/arm/nce/arm_nce.cpp index f7bdafd39..b42a32a0b 100644 --- a/src/core/arm/nce/arm_nce.cpp +++ b/src/core/arm/nce/arm_nce.cpp @@ -6,6 +6,7 @@ #include "common/signal_chain.h" #include "core/arm/nce/arm_nce.h" +#include "core/arm/nce/guest_context.h" #include "core/arm/nce/patcher.h" #include "core/core.h" #include "core/memory.h" @@ -38,7 +39,7 @@ fpsimd_context* GetFloatingPointState(mcontext_t& host_ctx) { } // namespace -void* ARM_NCE::RestoreGuestContext(void* raw_context) { +void* ArmNce::RestoreGuestContext(void* raw_context) { // Retrieve the host context. auto& host_ctx = static_cast<ucontext_t*>(raw_context)->uc_mcontext; @@ -71,7 +72,7 @@ void* ARM_NCE::RestoreGuestContext(void* raw_context) { return tpidr; } -void ARM_NCE::SaveGuestContext(GuestContext* guest_ctx, void* raw_context) { +void ArmNce::SaveGuestContext(GuestContext* guest_ctx, void* raw_context) { // Retrieve the host context. auto& host_ctx = static_cast<ucontext_t*>(raw_context)->uc_mcontext; @@ -103,7 +104,7 @@ void ARM_NCE::SaveGuestContext(GuestContext* guest_ctx, void* raw_context) { host_ctx.regs[0] = guest_ctx->esr_el1.exchange(0); } -bool ARM_NCE::HandleGuestFault(GuestContext* guest_ctx, void* raw_info, void* raw_context) { +bool ArmNce::HandleGuestFault(GuestContext* guest_ctx, void* raw_info, void* raw_context) { auto& host_ctx = static_cast<ucontext_t*>(raw_context)->uc_mcontext; auto* info = static_cast<siginfo_t*>(raw_info); @@ -134,7 +135,7 @@ bool ARM_NCE::HandleGuestFault(GuestContext* guest_ctx, void* raw_info, void* ra // - If we lose the race, then SignalInterrupt will send us a signal we are masking, // and it will do nothing when it is unmasked, as we have already left guest code. // - If we win the race, then SignalInterrupt will wait for us to unlock first. - auto& thread_params = guest_ctx->parent->running_thread->GetNativeExecutionParameters(); + auto& thread_params = guest_ctx->parent->m_running_thread->GetNativeExecutionParameters(); thread_params.lock.store(SpinLockLocked); // Return to host. @@ -142,97 +143,93 @@ bool ARM_NCE::HandleGuestFault(GuestContext* guest_ctx, void* raw_info, void* ra return false; } -void ARM_NCE::HandleHostFault(int sig, void* raw_info, void* raw_context) { +void ArmNce::HandleHostFault(int sig, void* raw_info, void* raw_context) { return g_orig_action.sa_sigaction(sig, static_cast<siginfo_t*>(raw_info), raw_context); } -HaltReason ARM_NCE::RunJit() { - // Get the thread parameters. - // TODO: pass the current thread down from ::Run - auto* thread = Kernel::GetCurrentThreadPointer(system.Kernel()); +void ArmNce::LockThread(Kernel::KThread* thread) { auto* thread_params = &thread->GetNativeExecutionParameters(); + LockThreadParameters(thread_params); +} - { - // Lock our core context. - std::scoped_lock lk{lock}; - - // We should not be running. - ASSERT(running_thread == nullptr); - - // Check if we need to run. If we have already been halted, we are done. - u64 halt = guest_ctx.esr_el1.exchange(0); - if (halt != 0) { - return static_cast<HaltReason>(halt); - } - - // Mark that we are running. - running_thread = thread; +void ArmNce::UnlockThread(Kernel::KThread* thread) { + auto* thread_params = &thread->GetNativeExecutionParameters(); + UnlockThreadParameters(thread_params); +} - // Acquire the lock on the thread parameters. - // This allows us to force synchronization with SignalInterrupt. - LockThreadParameters(thread_params); +HaltReason ArmNce::RunThread(Kernel::KThread* thread) { + // Check if we're already interrupted. + // If we are, we can just return immediately. + HaltReason hr = static_cast<HaltReason>(m_guest_ctx.esr_el1.exchange(0)); + if (True(hr)) { + return hr; } + // Get the thread context. + auto* thread_params = &thread->GetNativeExecutionParameters(); + auto* process = thread->GetOwnerProcess(); + // Assign current members. - guest_ctx.parent = this; - thread_params->native_context = &guest_ctx; - thread_params->tpidr_el0 = guest_ctx.tpidr_el0; - thread_params->tpidrro_el0 = guest_ctx.tpidrro_el0; + m_running_thread = thread; + m_guest_ctx.parent = this; + thread_params->native_context = &m_guest_ctx; + thread_params->tpidr_el0 = m_guest_ctx.tpidr_el0; + thread_params->tpidrro_el0 = m_guest_ctx.tpidrro_el0; thread_params->is_running = true; - HaltReason halt{}; - // TODO: finding and creating the post handler needs to be locked // to deal with dynamic loading of NROs. - const auto& post_handlers = system.ApplicationProcess()->GetPostHandlers(); - if (auto it = post_handlers.find(guest_ctx.pc); it != post_handlers.end()) { - halt = ReturnToRunCodeByTrampoline(thread_params, &guest_ctx, it->second); + const auto& post_handlers = process->GetPostHandlers(); + if (auto it = post_handlers.find(m_guest_ctx.pc); it != post_handlers.end()) { + hr = ReturnToRunCodeByTrampoline(thread_params, &m_guest_ctx, it->second); } else { - halt = ReturnToRunCodeByExceptionLevelChange(thread_id, thread_params); + hr = ReturnToRunCodeByExceptionLevelChange(m_thread_id, thread_params); } // Unload members. // The thread does not change, so we can persist the old reference. - guest_ctx.tpidr_el0 = thread_params->tpidr_el0; + m_running_thread = nullptr; + m_guest_ctx.tpidr_el0 = thread_params->tpidr_el0; thread_params->native_context = nullptr; thread_params->is_running = false; - // Unlock the thread parameters. - UnlockThreadParameters(thread_params); - - { - // Lock the core context. - std::scoped_lock lk{lock}; - - // On exit, we no longer have an active thread. - running_thread = nullptr; - } - // Return the halt reason. - return halt; + return hr; } -HaltReason ARM_NCE::StepJit() { +HaltReason ArmNce::StepThread(Kernel::KThread* thread) { return HaltReason::StepThread; } -u32 ARM_NCE::GetSvcNumber() const { - return guest_ctx.svc_swi; +u32 ArmNce::GetSvcNumber() const { + return m_guest_ctx.svc; +} + +void ArmNce::GetSvcArguments(std::span<uint64_t, 8> args) const { + for (size_t i = 0; i < 8; i++) { + args[i] = m_guest_ctx.cpu_registers[i]; + } +} + +void ArmNce::SetSvcArguments(std::span<const uint64_t, 8> args) { + for (size_t i = 0; i < 8; i++) { + m_guest_ctx.cpu_registers[i] = args[i]; + } } -ARM_NCE::ARM_NCE(System& system_, bool uses_wall_clock_, std::size_t core_index_) - : ARM_Interface{system_, uses_wall_clock_}, core_index{core_index_} { - guest_ctx.system = &system_; +ArmNce::ArmNce(System& system, bool uses_wall_clock, std::size_t core_index) + : ArmInterface{uses_wall_clock}, m_system{system}, m_core_index{core_index} { + m_guest_ctx.system = &m_system; } -ARM_NCE::~ARM_NCE() = default; +ArmNce::~ArmNce() = default; -void ARM_NCE::Initialize() { - thread_id = gettid(); +void ArmNce::Initialize() { + m_thread_id = gettid(); // Setup our signals - static std::once_flag flag; - std::call_once(flag, [] { + static std::once_flag signals; + std::call_once(signals, [] { using HandlerType = decltype(sigaction::sa_sigaction); sigset_t signal_mask; @@ -244,7 +241,7 @@ void ARM_NCE::Initialize() { struct sigaction return_to_run_code_action {}; return_to_run_code_action.sa_flags = SA_SIGINFO | SA_ONSTACK; return_to_run_code_action.sa_sigaction = reinterpret_cast<HandlerType>( - &ARM_NCE::ReturnToRunCodeByExceptionLevelChangeSignalHandler); + &ArmNce::ReturnToRunCodeByExceptionLevelChangeSignalHandler); return_to_run_code_action.sa_mask = signal_mask; Common::SigAction(ReturnToRunCodeByExceptionLevelChangeSignal, &return_to_run_code_action, nullptr); @@ -252,14 +249,13 @@ void ARM_NCE::Initialize() { struct sigaction break_from_run_code_action {}; break_from_run_code_action.sa_flags = SA_SIGINFO | SA_ONSTACK; break_from_run_code_action.sa_sigaction = - reinterpret_cast<HandlerType>(&ARM_NCE::BreakFromRunCodeSignalHandler); + reinterpret_cast<HandlerType>(&ArmNce::BreakFromRunCodeSignalHandler); break_from_run_code_action.sa_mask = signal_mask; Common::SigAction(BreakFromRunCodeSignal, &break_from_run_code_action, nullptr); struct sigaction fault_action {}; fault_action.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESTART; - fault_action.sa_sigaction = - reinterpret_cast<HandlerType>(&ARM_NCE::GuestFaultSignalHandler); + fault_action.sa_sigaction = reinterpret_cast<HandlerType>(&ArmNce::GuestFaultSignalHandler); fault_action.sa_mask = signal_mask; Common::SigAction(GuestFaultSignal, &fault_action, &g_orig_action); @@ -272,111 +268,59 @@ void ARM_NCE::Initialize() { }); } -void ARM_NCE::SetPC(u64 pc) { - guest_ctx.pc = pc; +void ArmNce::SetTpidrroEl0(u64 value) { + m_guest_ctx.tpidrro_el0 = value; } -u64 ARM_NCE::GetPC() const { - return guest_ctx.pc; -} - -u64 ARM_NCE::GetSP() const { - return guest_ctx.sp; -} - -u64 ARM_NCE::GetReg(int index) const { - return guest_ctx.cpu_registers[index]; -} - -void ARM_NCE::SetReg(int index, u64 value) { - guest_ctx.cpu_registers[index] = value; -} - -u128 ARM_NCE::GetVectorReg(int index) const { - return guest_ctx.vector_registers[index]; -} - -void ARM_NCE::SetVectorReg(int index, u128 value) { - guest_ctx.vector_registers[index] = value; -} - -u32 ARM_NCE::GetPSTATE() const { - return guest_ctx.pstate; -} - -void ARM_NCE::SetPSTATE(u32 pstate) { - guest_ctx.pstate = pstate; -} - -u64 ARM_NCE::GetTlsAddress() const { - return guest_ctx.tpidrro_el0; -} - -void ARM_NCE::SetTlsAddress(u64 address) { - guest_ctx.tpidrro_el0 = address; -} - -u64 ARM_NCE::GetTPIDR_EL0() const { - return guest_ctx.tpidr_el0; -} - -void ARM_NCE::SetTPIDR_EL0(u64 value) { - guest_ctx.tpidr_el0 = value; -} - -void ARM_NCE::SaveContext(ThreadContext64& ctx) const { - ctx.cpu_registers = guest_ctx.cpu_registers; - ctx.sp = guest_ctx.sp; - ctx.pc = guest_ctx.pc; - ctx.pstate = guest_ctx.pstate; - ctx.vector_registers = guest_ctx.vector_registers; - ctx.fpcr = guest_ctx.fpcr; - ctx.fpsr = guest_ctx.fpsr; - ctx.tpidr = guest_ctx.tpidr_el0; +void ArmNce::GetContext(Kernel::Svc::ThreadContext& ctx) const { + for (size_t i = 0; i < 29; i++) { + ctx.r[i] = m_guest_ctx.cpu_registers[i]; + } + ctx.fp = m_guest_ctx.cpu_registers[29]; + ctx.lr = m_guest_ctx.cpu_registers[30]; + ctx.sp = m_guest_ctx.sp; + ctx.pc = m_guest_ctx.pc; + ctx.pstate = m_guest_ctx.pstate; + ctx.v = m_guest_ctx.vector_registers; + ctx.fpcr = m_guest_ctx.fpcr; + ctx.fpsr = m_guest_ctx.fpsr; + ctx.tpidr = m_guest_ctx.tpidr_el0; } -void ARM_NCE::LoadContext(const ThreadContext64& ctx) { - guest_ctx.cpu_registers = ctx.cpu_registers; - guest_ctx.sp = ctx.sp; - guest_ctx.pc = ctx.pc; - guest_ctx.pstate = ctx.pstate; - guest_ctx.vector_registers = ctx.vector_registers; - guest_ctx.fpcr = ctx.fpcr; - guest_ctx.fpsr = ctx.fpsr; - guest_ctx.tpidr_el0 = ctx.tpidr; +void ArmNce::SetContext(const Kernel::Svc::ThreadContext& ctx) { + for (size_t i = 0; i < 29; i++) { + m_guest_ctx.cpu_registers[i] = ctx.r[i]; + } + m_guest_ctx.cpu_registers[29] = ctx.fp; + m_guest_ctx.cpu_registers[30] = ctx.lr; + m_guest_ctx.sp = ctx.sp; + m_guest_ctx.pc = ctx.pc; + m_guest_ctx.pstate = ctx.pstate; + m_guest_ctx.vector_registers = ctx.v; + m_guest_ctx.fpcr = ctx.fpcr; + m_guest_ctx.fpsr = ctx.fpsr; + m_guest_ctx.tpidr_el0 = ctx.tpidr; } -void ARM_NCE::SignalInterrupt() { - // Lock core context. - std::scoped_lock lk{lock}; - +void ArmNce::SignalInterrupt(Kernel::KThread* thread) { // Add break loop condition. - guest_ctx.esr_el1.fetch_or(static_cast<u64>(HaltReason::BreakLoop)); - - // If there is no thread running, we are done. - if (running_thread == nullptr) { - return; - } + m_guest_ctx.esr_el1.fetch_or(static_cast<u64>(HaltReason::BreakLoop)); // Lock the thread context. - auto* params = &running_thread->GetNativeExecutionParameters(); + auto* params = &thread->GetNativeExecutionParameters(); LockThreadParameters(params); if (params->is_running) { // We should signal to the running thread. // The running thread will unlock the thread context. - syscall(SYS_tkill, thread_id, BreakFromRunCodeSignal); + syscall(SYS_tkill, m_thread_id, BreakFromRunCodeSignal); } else { // If the thread is no longer running, we have nothing to do. UnlockThreadParameters(params); } } -void ARM_NCE::ClearInterrupt() { - guest_ctx.esr_el1 = {}; -} - -void ARM_NCE::ClearInstructionCache() { +void ArmNce::ClearInstructionCache() { // TODO: This is not possible to implement correctly on Linux because // we do not have any access to ic iallu. @@ -384,17 +328,8 @@ void ARM_NCE::ClearInstructionCache() { std::atomic_thread_fence(std::memory_order_seq_cst); } -void ARM_NCE::InvalidateCacheRange(u64 addr, std::size_t size) { +void ArmNce::InvalidateCacheRange(u64 addr, std::size_t size) { this->ClearInstructionCache(); } -void ARM_NCE::ClearExclusiveState() { - // No-op. -} - -void ARM_NCE::PageTableChanged(Common::PageTable& page_table, - std::size_t new_address_space_size_in_bits) { - // No-op. Page table is never used. -} - } // namespace Core diff --git a/src/core/arm/nce/arm_nce.h b/src/core/arm/nce/arm_nce.h index 5fbd6dbf3..f55c10d1d 100644 --- a/src/core/arm/nce/arm_nce.h +++ b/src/core/arm/nce/arm_nce.h @@ -3,11 +3,7 @@ #pragma once -#include <atomic> -#include <memory> -#include <span> -#include <unordered_map> -#include <vector> +#include <mutex> #include "core/arm/arm_interface.h" #include "core/arm/nce/guest_context.h" @@ -20,51 +16,36 @@ namespace Core { class System; -class ARM_NCE final : public ARM_Interface { +class ArmNce final : public ArmInterface { public: - ARM_NCE(System& system_, bool uses_wall_clock_, std::size_t core_index_); - - ~ARM_NCE() override; + ArmNce(System& system, bool uses_wall_clock, std::size_t core_index); + ~ArmNce() override; void Initialize() override; - void SetPC(u64 pc) override; - u64 GetPC() const override; - u64 GetSP() const override; - u64 GetReg(int index) const override; - void SetReg(int index, u64 value) override; - u128 GetVectorReg(int index) const override; - void SetVectorReg(int index, u128 value) override; - - u32 GetPSTATE() const override; - void SetPSTATE(u32 pstate) override; - u64 GetTlsAddress() const override; - void SetTlsAddress(u64 address) override; - void SetTPIDR_EL0(u64 value) override; - u64 GetTPIDR_EL0() const override; Architecture GetArchitecture() const override { - return Architecture::Aarch64; + return Architecture::AArch64; } - void SaveContext(ThreadContext32& ctx) const override {} - void SaveContext(ThreadContext64& ctx) const override; - void LoadContext(const ThreadContext32& ctx) override {} - void LoadContext(const ThreadContext64& ctx) override; + HaltReason RunThread(Kernel::KThread* thread) override; + HaltReason StepThread(Kernel::KThread* thread) override; + + void GetContext(Kernel::Svc::ThreadContext& ctx) const override; + void SetContext(const Kernel::Svc::ThreadContext& ctx) override; + void SetTpidrroEl0(u64 value) override; - void SignalInterrupt() override; - void ClearInterrupt() override; - void ClearExclusiveState() override; + void GetSvcArguments(std::span<uint64_t, 8> args) const override; + void SetSvcArguments(std::span<const uint64_t, 8> args) override; + u32 GetSvcNumber() const override; + + void SignalInterrupt(Kernel::KThread* thread) override; void ClearInstructionCache() override; void InvalidateCacheRange(u64 addr, std::size_t size) override; - void PageTableChanged(Common::PageTable& new_page_table, - std::size_t new_address_space_size_in_bits) override; - -protected: - HaltReason RunJit() override; - HaltReason StepJit() override; - u32 GetSvcNumber() const override; + void LockThread(Kernel::KThread* thread) override; + void UnlockThread(Kernel::KThread* thread) override; +protected: const Kernel::DebugWatchpoint* HaltedWatchpoint() const override { return nullptr; } @@ -93,16 +74,15 @@ private: static void HandleHostFault(int sig, void* info, void* raw_context); public: + Core::System& m_system; + // Members set on initialization. - std::size_t core_index{}; - pid_t thread_id{-1}; + std::size_t m_core_index{}; + pid_t m_thread_id{-1}; // Core context. - GuestContext guest_ctx; - - // Thread and invalidation info. - std::mutex lock; - Kernel::KThread* running_thread{}; + GuestContext m_guest_ctx{}; + Kernel::KThread* m_running_thread{}; }; } // namespace Core diff --git a/src/core/arm/nce/arm_nce.s b/src/core/arm/nce/arm_nce.s index b98e09f31..4aeda4740 100644 --- a/src/core/arm/nce/arm_nce.s +++ b/src/core/arm/nce/arm_nce.s @@ -8,11 +8,11 @@ movk reg, #(((val) >> 0x10) & 0xFFFF), lsl #16 -/* static HaltReason Core::ARM_NCE::ReturnToRunCodeByTrampoline(void* tpidr, Core::GuestContext* ctx, u64 trampoline_addr) */ -.section .text._ZN4Core7ARM_NCE27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm, "ax", %progbits -.global _ZN4Core7ARM_NCE27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm -.type _ZN4Core7ARM_NCE27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm, %function -_ZN4Core7ARM_NCE27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm: +/* static HaltReason Core::ArmNce::ReturnToRunCodeByTrampoline(void* tpidr, Core::GuestContext* ctx, u64 trampoline_addr) */ +.section .text._ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm, "ax", %progbits +.global _ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm +.type _ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm, %function +_ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm: /* Back up host sp to x3. */ /* Back up host tpidr_el0 to x4. */ mov x3, sp @@ -49,11 +49,11 @@ _ZN4Core7ARM_NCE27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm: br x2 -/* static HaltReason Core::ARM_NCE::ReturnToRunCodeByExceptionLevelChange(int tid, void* tpidr) */ -.section .text._ZN4Core7ARM_NCE37ReturnToRunCodeByExceptionLevelChangeEiPv, "ax", %progbits -.global _ZN4Core7ARM_NCE37ReturnToRunCodeByExceptionLevelChangeEiPv -.type _ZN4Core7ARM_NCE37ReturnToRunCodeByExceptionLevelChangeEiPv, %function -_ZN4Core7ARM_NCE37ReturnToRunCodeByExceptionLevelChangeEiPv: +/* static HaltReason Core::ArmNce::ReturnToRunCodeByExceptionLevelChange(int tid, void* tpidr) */ +.section .text._ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv, "ax", %progbits +.global _ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv +.type _ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv, %function +_ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv: /* This jumps to the signal handler, which will restore the entire context. */ /* On entry, x0 = thread id, which is already in the right place. */ @@ -71,17 +71,17 @@ _ZN4Core7ARM_NCE37ReturnToRunCodeByExceptionLevelChangeEiPv: brk #1000 -/* static void Core::ARM_NCE::ReturnToRunCodeByExceptionLevelChangeSignalHandler(int sig, void* info, void* raw_context) */ -.section .text._ZN4Core7ARM_NCE50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_, "ax", %progbits -.global _ZN4Core7ARM_NCE50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_ -.type _ZN4Core7ARM_NCE50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_, %function -_ZN4Core7ARM_NCE50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_: +/* static void Core::ArmNce::ReturnToRunCodeByExceptionLevelChangeSignalHandler(int sig, void* info, void* raw_context) */ +.section .text._ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_, "ax", %progbits +.global _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_ +.type _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_, %function +_ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_: stp x29, x30, [sp, #-0x10]! mov x29, sp /* Call the context restorer with the raw context. */ mov x0, x2 - bl _ZN4Core7ARM_NCE19RestoreGuestContextEPv + bl _ZN4Core6ArmNce19RestoreGuestContextEPv /* Save the old value of tpidr_el0. */ mrs x8, tpidr_el0 @@ -92,18 +92,18 @@ _ZN4Core7ARM_NCE50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_: msr tpidr_el0, x0 /* Unlock the context. */ - bl _ZN4Core7ARM_NCE22UnlockThreadParametersEPv + bl _ZN4Core6ArmNce22UnlockThreadParametersEPv /* Returning from here will enter the guest. */ ldp x29, x30, [sp], #0x10 ret -/* static void Core::ARM_NCE::BreakFromRunCodeSignalHandler(int sig, void* info, void* raw_context) */ -.section .text._ZN4Core7ARM_NCE29BreakFromRunCodeSignalHandlerEiPvS1_, "ax", %progbits -.global _ZN4Core7ARM_NCE29BreakFromRunCodeSignalHandlerEiPvS1_ -.type _ZN4Core7ARM_NCE29BreakFromRunCodeSignalHandlerEiPvS1_, %function -_ZN4Core7ARM_NCE29BreakFromRunCodeSignalHandlerEiPvS1_: +/* static void Core::ArmNce::BreakFromRunCodeSignalHandler(int sig, void* info, void* raw_context) */ +.section .text._ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_, "ax", %progbits +.global _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_ +.type _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_, %function +_ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_: /* Check to see if we have the correct TLS magic. */ mrs x8, tpidr_el0 ldr w9, [x8, #(TpidrEl0TlsMagic)] @@ -121,7 +121,7 @@ _ZN4Core7ARM_NCE29BreakFromRunCodeSignalHandlerEiPvS1_: /* Tail call the restorer. */ mov x1, x2 - b _ZN4Core7ARM_NCE16SaveGuestContextEPNS_12GuestContextEPv + b _ZN4Core6ArmNce16SaveGuestContextEPNS_12GuestContextEPv /* Returning from here will enter host code. */ @@ -130,11 +130,11 @@ _ZN4Core7ARM_NCE29BreakFromRunCodeSignalHandlerEiPvS1_: ret -/* static void Core::ARM_NCE::GuestFaultSignalHandler(int sig, void* info, void* raw_context) */ -.section .text._ZN4Core7ARM_NCE23GuestFaultSignalHandlerEiPvS1_, "ax", %progbits -.global _ZN4Core7ARM_NCE23GuestFaultSignalHandlerEiPvS1_ -.type _ZN4Core7ARM_NCE23GuestFaultSignalHandlerEiPvS1_, %function -_ZN4Core7ARM_NCE23GuestFaultSignalHandlerEiPvS1_: +/* static void Core::ArmNce::GuestFaultSignalHandler(int sig, void* info, void* raw_context) */ +.section .text._ZN4Core6ArmNce23GuestFaultSignalHandlerEiPvS1_, "ax", %progbits +.global _ZN4Core6ArmNce23GuestFaultSignalHandlerEiPvS1_ +.type _ZN4Core6ArmNce23GuestFaultSignalHandlerEiPvS1_, %function +_ZN4Core6ArmNce23GuestFaultSignalHandlerEiPvS1_: /* Check to see if we have the correct TLS magic. */ mrs x8, tpidr_el0 ldr w9, [x8, #(TpidrEl0TlsMagic)] @@ -146,7 +146,7 @@ _ZN4Core7ARM_NCE23GuestFaultSignalHandlerEiPvS1_: /* Incorrect TLS magic, so this is a host fault. */ /* Tail call the handler. */ - b _ZN4Core7ARM_NCE15HandleHostFaultEiPvS1_ + b _ZN4Core6ArmNce15HandleHostFaultEiPvS1_ 1: /* Correct TLS magic, so this is a guest fault. */ @@ -163,7 +163,7 @@ _ZN4Core7ARM_NCE23GuestFaultSignalHandlerEiPvS1_: msr tpidr_el0, x3 /* Call the handler. */ - bl _ZN4Core7ARM_NCE16HandleGuestFaultEPNS_12GuestContextEPvS3_ + bl _ZN4Core6ArmNce16HandleGuestFaultEPNS_12GuestContextEPvS3_ /* If the handler returned false, we want to preserve the host tpidr_el0. */ cbz x0, 2f @@ -177,11 +177,11 @@ _ZN4Core7ARM_NCE23GuestFaultSignalHandlerEiPvS1_: ret -/* static void Core::ARM_NCE::LockThreadParameters(void* tpidr) */ -.section .text._ZN4Core7ARM_NCE20LockThreadParametersEPv, "ax", %progbits -.global _ZN4Core7ARM_NCE20LockThreadParametersEPv -.type _ZN4Core7ARM_NCE20LockThreadParametersEPv, %function -_ZN4Core7ARM_NCE20LockThreadParametersEPv: +/* static void Core::ArmNce::LockThreadParameters(void* tpidr) */ +.section .text._ZN4Core6ArmNce20LockThreadParametersEPv, "ax", %progbits +.global _ZN4Core6ArmNce20LockThreadParametersEPv +.type _ZN4Core6ArmNce20LockThreadParametersEPv, %function +_ZN4Core6ArmNce20LockThreadParametersEPv: /* Offset to lock member. */ add x0, x0, #(TpidrEl0Lock) @@ -205,11 +205,11 @@ _ZN4Core7ARM_NCE20LockThreadParametersEPv: ret -/* static void Core::ARM_NCE::UnlockThreadParameters(void* tpidr) */ -.section .text._ZN4Core7ARM_NCE22UnlockThreadParametersEPv, "ax", %progbits -.global _ZN4Core7ARM_NCE22UnlockThreadParametersEPv -.type _ZN4Core7ARM_NCE22UnlockThreadParametersEPv, %function -_ZN4Core7ARM_NCE22UnlockThreadParametersEPv: +/* static void Core::ArmNce::UnlockThreadParameters(void* tpidr) */ +.section .text._ZN4Core6ArmNce22UnlockThreadParametersEPv, "ax", %progbits +.global _ZN4Core6ArmNce22UnlockThreadParametersEPv +.type _ZN4Core6ArmNce22UnlockThreadParametersEPv, %function +_ZN4Core6ArmNce22UnlockThreadParametersEPv: /* Offset to lock member. */ add x0, x0, #(TpidrEl0Lock) diff --git a/src/core/arm/nce/guest_context.h b/src/core/arm/nce/guest_context.h index 0767a0337..a7eadccce 100644 --- a/src/core/arm/nce/guest_context.h +++ b/src/core/arm/nce/guest_context.h @@ -3,6 +3,8 @@ #pragma once +#include <atomic> + #include "common/common_funcs.h" #include "common/common_types.h" #include "core/arm/arm_interface.h" @@ -10,7 +12,7 @@ namespace Core { -class ARM_NCE; +class ArmNce; class System; struct HostContext { @@ -33,9 +35,9 @@ struct GuestContext { u64 tpidr_el0{}; std::atomic<u64> esr_el1{}; u32 nzcv{}; - u32 svc_swi{}; + u32 svc{}; System* system{}; - ARM_NCE* parent{}; + ArmNce* parent{}; }; // Verify assembly offsets. diff --git a/src/core/arm/nce/patcher.cpp b/src/core/arm/nce/patcher.cpp index bdaa3af49..47a7a8880 100644 --- a/src/core/arm/nce/patcher.cpp +++ b/src/core/arm/nce/patcher.cpp @@ -280,7 +280,7 @@ void Patcher::WriteSvcTrampoline(ModuleDestLabel module_dest, u32 svc_id) { // Store SVC number to execute when we return c.MOV(X2, svc_id); - c.STR(W2, X1, offsetof(GuestContext, svc_swi)); + c.STR(W2, X1, offsetof(GuestContext, svc)); // We are calling a SVC. Clear esr_el1 and return it. static_assert(std::is_same_v<std::underlying_type_t<HaltReason>, u64>); diff --git a/src/core/core.cpp b/src/core/core.cpp index 14d6c8c27..b14f74976 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -36,6 +36,7 @@ #include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/physical_core.h" +#include "core/hle/service/acc/profile_manager.h" #include "core/hle/service/am/applets/applets.h" #include "core/hle/service/apm/apm_controller.h" #include "core/hle/service/filesystem/filesystem.h" @@ -130,8 +131,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs, struct System::Impl { explicit Impl(System& system) : kernel{system}, fs_controller{system}, memory{system}, hid_core{}, room_network{}, - cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system}, - gpu_dirty_memory_write_manager{} { + cpu_manager{system}, reporter{system}, applet_manager{system}, profile_manager{}, + time_manager{system}, gpu_dirty_memory_write_manager{} { memory.SetGPUDirtyManagers(gpu_dirty_memory_write_manager); } @@ -323,7 +324,6 @@ struct System::Impl { static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result)); } AddGlueRegistrationForProcess(*app_loader, *main_process); - kernel.InitializeCores(); // Initialize cheat engine if (cheat_engine) { @@ -533,6 +533,7 @@ struct System::Impl { /// Service State Service::Glue::ARPManager arp_manager; + Service::Account::ProfileManager profile_manager; Service::Time::TimeManager time_manager; /// Service manager @@ -600,14 +601,6 @@ bool System::IsPaused() const { return impl->IsPaused(); } -void System::InvalidateCpuInstructionCaches() { - impl->kernel.InvalidateAllInstructionCaches(); -} - -void System::InvalidateCpuInstructionCacheRange(u64 addr, std::size_t size) { - impl->kernel.InvalidateCpuInstructionCacheRange(addr, size); -} - void System::ShutdownMainProcess() { impl->ShutdownMainProcess(); } @@ -696,14 +689,6 @@ const TelemetrySession& System::TelemetrySession() const { return *impl->telemetry_session; } -ARM_Interface& System::CurrentArmInterface() { - return impl->kernel.CurrentPhysicalCore().ArmInterface(); -} - -const ARM_Interface& System::CurrentArmInterface() const { - return impl->kernel.CurrentPhysicalCore().ArmInterface(); -} - Kernel::PhysicalCore& System::CurrentPhysicalCore() { return impl->kernel.CurrentPhysicalCore(); } @@ -738,14 +723,6 @@ const Kernel::KProcess* System::ApplicationProcess() const { return impl->kernel.ApplicationProcess(); } -ARM_Interface& System::ArmInterface(std::size_t core_index) { - return impl->kernel.PhysicalCore(core_index).ArmInterface(); -} - -const ARM_Interface& System::ArmInterface(std::size_t core_index) const { - return impl->kernel.PhysicalCore(core_index).ArmInterface(); -} - ExclusiveMonitor& System::Monitor() { return impl->kernel.GetExclusiveMonitor(); } @@ -946,6 +923,14 @@ const Service::APM::Controller& System::GetAPMController() const { return impl->apm_controller; } +Service::Account::ProfileManager& System::GetProfileManager() { + return impl->profile_manager; +} + +const Service::Account::ProfileManager& System::GetProfileManager() const { + return impl->profile_manager; +} + Service::Time::TimeManager& System::GetTimeManager() { return impl->time_manager; } diff --git a/src/core/core.h b/src/core/core.h index df20f26f3..473204db7 100644 --- a/src/core/core.h +++ b/src/core/core.h @@ -45,6 +45,10 @@ class Memory; namespace Service { +namespace Account { +class ProfileManager; +} // namespace Account + namespace AM::Applets { struct AppletFrontendSet; class AppletManager; @@ -108,7 +112,6 @@ class RenderdocAPI; namespace Core { -class ARM_Interface; class CpuManager; class Debugger; class DeviceMemory; @@ -171,15 +174,6 @@ public: /// Check if the core is currently paused. [[nodiscard]] bool IsPaused() const; - /** - * Invalidate the CPU instruction caches - * This function should only be used by GDB Stub to support breakpoints, memory updates and - * step/continue commands. - */ - void InvalidateCpuInstructionCaches(); - - void InvalidateCpuInstructionCacheRange(u64 addr, std::size_t size); - /// Shutdown the main emulated process. void ShutdownMainProcess(); @@ -244,24 +238,12 @@ public: /// Gets and resets core performance statistics [[nodiscard]] PerfStatsResults GetAndResetPerfStats(); - /// Gets an ARM interface to the CPU core that is currently running - [[nodiscard]] ARM_Interface& CurrentArmInterface(); - - /// Gets an ARM interface to the CPU core that is currently running - [[nodiscard]] const ARM_Interface& CurrentArmInterface() const; - /// Gets the physical core for the CPU core that is currently running [[nodiscard]] Kernel::PhysicalCore& CurrentPhysicalCore(); /// Gets the physical core for the CPU core that is currently running [[nodiscard]] const Kernel::PhysicalCore& CurrentPhysicalCore() const; - /// Gets a reference to an ARM interface for the CPU core with the specified index - [[nodiscard]] ARM_Interface& ArmInterface(std::size_t core_index); - - /// Gets a const reference to an ARM interface from the CPU core with the specified index - [[nodiscard]] const ARM_Interface& ArmInterface(std::size_t core_index) const; - /// Gets a reference to the underlying CPU manager. [[nodiscard]] CpuManager& GetCpuManager(); @@ -405,6 +387,9 @@ public: [[nodiscard]] Service::APM::Controller& GetAPMController(); [[nodiscard]] const Service::APM::Controller& GetAPMController() const; + [[nodiscard]] Service::Account::ProfileManager& GetProfileManager(); + [[nodiscard]] const Service::Account::ProfileManager& GetProfileManager() const; + [[nodiscard]] Service::Time::TimeManager& GetTimeManager(); [[nodiscard]] const Service::Time::TimeManager& GetTimeManager() const; diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cpp index 151eb3870..7a5c22f78 100644 --- a/src/core/cpu_manager.cpp +++ b/src/core/cpu_manager.cpp @@ -73,12 +73,13 @@ void CpuManager::HandleInterrupt() { void CpuManager::MultiCoreRunGuestThread() { // Similar to UserModeThreadStarter in HOS auto& kernel = system.Kernel(); + auto* thread = Kernel::GetCurrentThreadPointer(kernel); kernel.CurrentScheduler()->OnThreadStart(); while (true) { auto* physical_core = &kernel.CurrentPhysicalCore(); while (!physical_core->IsInterrupted()) { - physical_core->Run(); + physical_core->RunThread(thread); physical_core = &kernel.CurrentPhysicalCore(); } @@ -110,12 +111,13 @@ void CpuManager::MultiCoreRunIdleThread() { void CpuManager::SingleCoreRunGuestThread() { auto& kernel = system.Kernel(); + auto* thread = Kernel::GetCurrentThreadPointer(kernel); kernel.CurrentScheduler()->OnThreadStart(); while (true) { auto* physical_core = &kernel.CurrentPhysicalCore(); if (!physical_core->IsInterrupted()) { - physical_core->Run(); + physical_core->RunThread(thread); physical_core = &kernel.CurrentPhysicalCore(); } @@ -211,8 +213,6 @@ void CpuManager::RunThread(std::stop_token token, std::size_t core) { system.GPU().ObtainContext(); } - system.ArmInterface(core).Initialize(); - auto& kernel = system.Kernel(); auto& scheduler = *kernel.CurrentScheduler(); auto* thread = scheduler.GetSchedulerCurrentThread(); diff --git a/src/core/debugger/gdbstub.cpp b/src/core/debugger/gdbstub.cpp index 148dd3e39..66e46c4ba 100644 --- a/src/core/debugger/gdbstub.cpp +++ b/src/core/debugger/gdbstub.cpp @@ -16,6 +16,7 @@ #include "common/settings.h" #include "common/string_util.h" #include "core/arm/arm_interface.h" +#include "core/arm/debug.h" #include "core/core.h" #include "core/debugger/gdbstub.h" #include "core/debugger/gdbstub_arch.h" @@ -310,7 +311,7 @@ void GDBStub::ExecuteCommand(std::string_view packet, std::vector<DebuggerAction const auto mem{Common::HexStringToVector(mem_substr, false)}; if (system.ApplicationMemory().WriteBlock(addr, mem.data(), size)) { - system.InvalidateCpuInstructionCacheRange(addr, size); + Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), addr, size); SendReply(GDB_STUB_REPLY_OK); } else { SendReply(GDB_STUB_REPLY_ERR); @@ -363,7 +364,7 @@ void GDBStub::HandleBreakpointInsert(std::string_view command) { case BreakpointType::Software: replaced_instructions[addr] = system.ApplicationMemory().Read32(addr); system.ApplicationMemory().Write32(addr, arch->BreakpointInstruction()); - system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32)); + Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), addr, sizeof(u32)); success = true; break; case BreakpointType::WriteWatch: @@ -411,7 +412,7 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) { const auto orig_insn{replaced_instructions.find(addr)}; if (orig_insn != replaced_instructions.end()) { system.ApplicationMemory().Write32(addr, orig_insn->second); - system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32)); + Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), addr, sizeof(u32)); replaced_instructions.erase(addr); success = true; } @@ -442,114 +443,6 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) { } } -// Structure offsets are from Atmosphere -// See osdbg_thread_local_region.os.horizon.hpp and osdbg_thread_type.os.horizon.hpp - -static std::optional<std::string> GetNameFromThreadType32(Core::Memory::Memory& memory, - const Kernel::KThread& thread) { - // Read thread type from TLS - const VAddr tls_thread_type{memory.Read32(thread.GetTlsAddress() + 0x1fc)}; - const VAddr argument_thread_type{thread.GetArgument()}; - - if (argument_thread_type && tls_thread_type != argument_thread_type) { - // Probably not created by nnsdk, no name available. - return std::nullopt; - } - - if (!tls_thread_type) { - return std::nullopt; - } - - const u16 version{memory.Read16(tls_thread_type + 0x26)}; - VAddr name_pointer{}; - if (version == 1) { - name_pointer = memory.Read32(tls_thread_type + 0xe4); - } else { - name_pointer = memory.Read32(tls_thread_type + 0xe8); - } - - if (!name_pointer) { - // No name provided. - return std::nullopt; - } - - return memory.ReadCString(name_pointer, 256); -} - -static std::optional<std::string> GetNameFromThreadType64(Core::Memory::Memory& memory, - const Kernel::KThread& thread) { - // Read thread type from TLS - const VAddr tls_thread_type{memory.Read64(thread.GetTlsAddress() + 0x1f8)}; - const VAddr argument_thread_type{thread.GetArgument()}; - - if (argument_thread_type && tls_thread_type != argument_thread_type) { - // Probably not created by nnsdk, no name available. - return std::nullopt; - } - - if (!tls_thread_type) { - return std::nullopt; - } - - const u16 version{memory.Read16(tls_thread_type + 0x46)}; - VAddr name_pointer{}; - if (version == 1) { - name_pointer = memory.Read64(tls_thread_type + 0x1a0); - } else { - name_pointer = memory.Read64(tls_thread_type + 0x1a8); - } - - if (!name_pointer) { - // No name provided. - return std::nullopt; - } - - return memory.ReadCString(name_pointer, 256); -} - -static std::optional<std::string> GetThreadName(Core::System& system, - const Kernel::KThread& thread) { - if (system.ApplicationProcess()->Is64Bit()) { - return GetNameFromThreadType64(system.ApplicationMemory(), thread); - } else { - return GetNameFromThreadType32(system.ApplicationMemory(), thread); - } -} - -static std::string_view GetThreadWaitReason(const Kernel::KThread& thread) { - switch (thread.GetWaitReasonForDebugging()) { - case Kernel::ThreadWaitReasonForDebugging::Sleep: - return "Sleep"; - case Kernel::ThreadWaitReasonForDebugging::IPC: - return "IPC"; - case Kernel::ThreadWaitReasonForDebugging::Synchronization: - return "Synchronization"; - case Kernel::ThreadWaitReasonForDebugging::ConditionVar: - return "ConditionVar"; - case Kernel::ThreadWaitReasonForDebugging::Arbitration: - return "Arbitration"; - case Kernel::ThreadWaitReasonForDebugging::Suspended: - return "Suspended"; - default: - return "Unknown"; - } -} - -static std::string GetThreadState(const Kernel::KThread& thread) { - switch (thread.GetState()) { - case Kernel::ThreadState::Initialized: - return "Initialized"; - case Kernel::ThreadState::Waiting: - return fmt::format("Waiting ({})", GetThreadWaitReason(thread)); - case Kernel::ThreadState::Runnable: - return "Runnable"; - case Kernel::ThreadState::Terminated: - return "Terminated"; - default: - return "Unknown"; - } -} - static std::string PaginateBuffer(std::string_view buffer, std::string_view request) { const auto amount{request.substr(request.find(',') + 1)}; const auto offset_val{static_cast<u64>(strtoll(request.data(), nullptr, 16))}; @@ -562,120 +455,6 @@ static std::string PaginateBuffer(std::string_view buffer, std::string_view requ } } -static VAddr GetModuleEnd(Kernel::KProcessPageTable& page_table, VAddr base) { - Kernel::KMemoryInfo mem_info; - Kernel::Svc::MemoryInfo svc_mem_info; - Kernel::Svc::PageInfo page_info; - VAddr cur_addr{base}; - - // Expect: r-x Code (.text) - R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); - svc_mem_info = mem_info.GetSvcMemoryInfo(); - cur_addr = svc_mem_info.base_address + svc_mem_info.size; - if (svc_mem_info.state != Kernel::Svc::MemoryState::Code || - svc_mem_info.permission != Kernel::Svc::MemoryPermission::ReadExecute) { - return cur_addr - 1; - } - - // Expect: r-- Code (.rodata) - R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); - svc_mem_info = mem_info.GetSvcMemoryInfo(); - cur_addr = svc_mem_info.base_address + svc_mem_info.size; - if (svc_mem_info.state != Kernel::Svc::MemoryState::Code || - svc_mem_info.permission != Kernel::Svc::MemoryPermission::Read) { - return cur_addr - 1; - } - - // Expect: rw- CodeData (.data) - R_ASSERT(page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); - svc_mem_info = mem_info.GetSvcMemoryInfo(); - cur_addr = svc_mem_info.base_address + svc_mem_info.size; - return cur_addr - 1; -} - -static Loader::AppLoader::Modules FindModules(Core::System& system) { - Loader::AppLoader::Modules modules; - - auto& page_table = system.ApplicationProcess()->GetPageTable(); - auto& memory = system.ApplicationMemory(); - VAddr cur_addr = 0; - - // Look for executable sections in Code or AliasCode regions. - while (true) { - Kernel::KMemoryInfo mem_info{}; - Kernel::Svc::PageInfo page_info{}; - R_ASSERT( - page_table.QueryInfo(std::addressof(mem_info), std::addressof(page_info), cur_addr)); - auto svc_mem_info = mem_info.GetSvcMemoryInfo(); - - if (svc_mem_info.permission == Kernel::Svc::MemoryPermission::ReadExecute && - (svc_mem_info.state == Kernel::Svc::MemoryState::Code || - svc_mem_info.state == Kernel::Svc::MemoryState::AliasCode)) { - // Try to read the module name from its path. - constexpr s32 PathLengthMax = 0x200; - struct { - u32 zero; - s32 path_length; - std::array<char, PathLengthMax> path; - } module_path; - - if (memory.ReadBlock(svc_mem_info.base_address + svc_mem_info.size, &module_path, - sizeof(module_path))) { - if (module_path.zero == 0 && module_path.path_length > 0) { - // Truncate module name. - module_path.path[PathLengthMax - 1] = '\0'; - - // Ignore leading directories. - char* path_pointer = module_path.path.data(); - - for (s32 i = 0; i < std::min(PathLengthMax, module_path.path_length) && - module_path.path[i] != '\0'; - i++) { - if (module_path.path[i] == '/' || module_path.path[i] == '\\') { - path_pointer = module_path.path.data() + i + 1; - } - } - - // Insert output. - modules.emplace(svc_mem_info.base_address, path_pointer); - } - } - } - - // Check if we're done. - const uintptr_t next_address = svc_mem_info.base_address + svc_mem_info.size; - if (next_address <= cur_addr) { - break; - } - - cur_addr = next_address; - } - - return modules; -} - -static VAddr FindMainModuleEntrypoint(Core::System& system) { - Loader::AppLoader::Modules modules; - system.GetAppLoader().ReadNSOModules(modules); - - // Do we have a module named main? - const auto main = std::find_if(modules.begin(), modules.end(), - [](const auto& key) { return key.second == "main"; }); - - if (main != modules.end()) { - return main->first; - } - - // Do we have any loaded executable sections? - modules = FindModules(system); - if (!modules.empty()) { - return modules.begin()->first; - } - - // As a last resort, use the start of the code region. - return GetInteger(system.ApplicationProcess()->GetPageTable().GetCodeRegionStart()); -} - void GDBStub::HandleQuery(std::string_view command) { if (command.starts_with("TStatus")) { // no tracepoint support @@ -687,10 +466,10 @@ void GDBStub::HandleQuery(std::string_view command) { const auto target_xml{arch->GetTargetXML()}; SendReply(PaginateBuffer(target_xml, command.substr(30))); } else if (command.starts_with("Offsets")) { - const auto main_offset = FindMainModuleEntrypoint(system); - SendReply(fmt::format("TextSeg={:x}", main_offset)); + const auto main_offset = Core::FindMainModuleEntrypoint(system.ApplicationProcess()); + SendReply(fmt::format("TextSeg={:x}", GetInteger(main_offset))); } else if (command.starts_with("Xfer:libraries:read::")) { - auto modules = FindModules(system); + auto modules = Core::FindModules(system.ApplicationProcess()); std::string buffer; buffer += R"(<?xml version="1.0"?>)"; @@ -720,14 +499,14 @@ void GDBStub::HandleQuery(std::string_view command) { const auto& threads = system.ApplicationProcess()->GetThreadList(); for (const auto& thread : threads) { - auto thread_name{GetThreadName(system, thread)}; + auto thread_name{Core::GetThreadName(&thread)}; if (!thread_name) { thread_name = fmt::format("Thread {:d}", thread.GetThreadId()); } buffer += fmt::format(R"(<thread id="{:x}" core="{:d}" name="{}">{}</thread>)", thread.GetThreadId(), thread.GetActiveCore(), - EscapeXML(*thread_name), GetThreadState(thread)); + EscapeXML(*thread_name), GetThreadState(&thread)); } buffer += "</threads>"; @@ -856,7 +635,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) { reply = "Fastmem is not enabled.\n"; } } else if (command_str == "get info") { - auto modules = FindModules(system); + auto modules = Core::FindModules(process); reply = fmt::format("Process: {:#x} ({})\n" "Program Id: {:#018x}\n", @@ -880,7 +659,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) { for (const auto& [vaddr, name] : modules) { reply += fmt::format(" {:#012x} - {:#012x} {}\n", vaddr, - GetModuleEnd(page_table, vaddr), name); + GetInteger(Core::GetModuleEnd(process, vaddr)), name); } } else if (command_str == "get mappings") { reply = "Mappings:\n"; diff --git a/src/core/debugger/gdbstub_arch.cpp b/src/core/debugger/gdbstub_arch.cpp index 75c94a91a..f2a407dc8 100644 --- a/src/core/debugger/gdbstub_arch.cpp +++ b/src/core/debugger/gdbstub_arch.cpp @@ -24,21 +24,6 @@ static std::string ValueToHex(const T value) { return Common::HexToString(mem); } -template <typename T> -static T GetSIMDRegister(const std::array<u32, 64>& simd_regs, size_t offset) { - static_assert(std::is_trivially_copyable_v<T>); - T value{}; - std::memcpy(&value, reinterpret_cast<const u8*>(simd_regs.data()) + sizeof(T) * offset, - sizeof(T)); - return value; -} - -template <typename T> -static void PutSIMDRegister(std::array<u32, 64>& simd_regs, size_t offset, const T value) { - static_assert(std::is_trivially_copyable_v<T>); - std::memcpy(reinterpret_cast<u8*>(simd_regs.data()) + sizeof(T) * offset, &value, sizeof(T)); -} - // For sample XML files see the GDB source /gdb/features // This XML defines what the registers are for this specific ARM device std::string_view GDBStubA64::GetTargetXML() const { @@ -184,12 +169,16 @@ std::string GDBStubA64::RegRead(const Kernel::KThread* thread, size_t id) const return ""; } - const auto& context{thread->GetContext64()}; - const auto& gprs{context.cpu_registers}; - const auto& fprs{context.vector_registers}; + const auto& context{thread->GetContext()}; + const auto& gprs{context.r}; + const auto& fprs{context.v}; - if (id < SP_REGISTER) { + if (id < FP_REGISTER) { return ValueToHex(gprs[id]); + } else if (id == FP_REGISTER) { + return ValueToHex(context.fp); + } else if (id == LR_REGISTER) { + return ValueToHex(context.lr); } else if (id == SP_REGISTER) { return ValueToHex(context.sp); } else if (id == PC_REGISTER) { @@ -212,10 +201,14 @@ void GDBStubA64::RegWrite(Kernel::KThread* thread, size_t id, std::string_view v return; } - auto& context{thread->GetContext64()}; + auto& context{thread->GetContext()}; - if (id < SP_REGISTER) { - context.cpu_registers[id] = HexToValue<u64>(value); + if (id < FP_REGISTER) { + context.r[id] = HexToValue<u64>(value); + } else if (id == FP_REGISTER) { + context.fp = HexToValue<u64>(value); + } else if (id == LR_REGISTER) { + context.lr = HexToValue<u64>(value); } else if (id == SP_REGISTER) { context.sp = HexToValue<u64>(value); } else if (id == PC_REGISTER) { @@ -223,7 +216,7 @@ void GDBStubA64::RegWrite(Kernel::KThread* thread, size_t id, std::string_view v } else if (id == PSTATE_REGISTER) { context.pstate = HexToValue<u32>(value); } else if (id >= Q0_REGISTER && id < FPSR_REGISTER) { - context.vector_registers[id - Q0_REGISTER] = HexToValue<u128>(value); + context.v[id - Q0_REGISTER] = HexToValue<u128>(value); } else if (id == FPSR_REGISTER) { context.fpsr = HexToValue<u32>(value); } else if (id == FPCR_REGISTER) { @@ -381,22 +374,20 @@ std::string GDBStubA32::RegRead(const Kernel::KThread* thread, size_t id) const return ""; } - const auto& context{thread->GetContext32()}; - const auto& gprs{context.cpu_registers}; - const auto& fprs{context.extension_registers}; + const auto& context{thread->GetContext()}; + const auto& gprs{context.r}; + const auto& fprs{context.v}; if (id <= PC_REGISTER) { - return ValueToHex(gprs[id]); + return ValueToHex(static_cast<u32>(gprs[id])); } else if (id == CPSR_REGISTER) { - return ValueToHex(context.cpsr); + return ValueToHex(context.pstate); } else if (id >= D0_REGISTER && id < Q0_REGISTER) { - const u64 dN{GetSIMDRegister<u64>(fprs, id - D0_REGISTER)}; - return ValueToHex(dN); + return ValueToHex(fprs[id - D0_REGISTER][0]); } else if (id >= Q0_REGISTER && id < FPSCR_REGISTER) { - const u128 qN{GetSIMDRegister<u128>(fprs, id - Q0_REGISTER)}; - return ValueToHex(qN); + return ValueToHex(fprs[id - Q0_REGISTER]); } else if (id == FPSCR_REGISTER) { - return ValueToHex(context.fpscr); + return ValueToHex(context.fpcr | context.fpsr); } else { return ""; } @@ -407,19 +398,20 @@ void GDBStubA32::RegWrite(Kernel::KThread* thread, size_t id, std::string_view v return; } - auto& context{thread->GetContext32()}; - auto& fprs{context.extension_registers}; + auto& context{thread->GetContext()}; + auto& fprs{context.v}; if (id <= PC_REGISTER) { - context.cpu_registers[id] = HexToValue<u32>(value); + context.r[id] = HexToValue<u32>(value); } else if (id == CPSR_REGISTER) { - context.cpsr = HexToValue<u32>(value); + context.pstate = HexToValue<u32>(value); } else if (id >= D0_REGISTER && id < Q0_REGISTER) { - PutSIMDRegister(fprs, id - D0_REGISTER, HexToValue<u64>(value)); + fprs[id - D0_REGISTER] = {HexToValue<u64>(value), 0}; } else if (id >= Q0_REGISTER && id < FPSCR_REGISTER) { - PutSIMDRegister(fprs, id - Q0_REGISTER, HexToValue<u128>(value)); + fprs[id - Q0_REGISTER] = HexToValue<u128>(value); } else if (id == FPSCR_REGISTER) { - context.fpscr = HexToValue<u32>(value); + context.fpcr = HexToValue<u32>(value); + context.fpsr = HexToValue<u32>(value); } } diff --git a/src/core/debugger/gdbstub_arch.h b/src/core/debugger/gdbstub_arch.h index 34530c788..d53714d69 100644 --- a/src/core/debugger/gdbstub_arch.h +++ b/src/core/debugger/gdbstub_arch.h @@ -36,6 +36,7 @@ public: u32 BreakpointInstruction() const override; private: + static constexpr u32 FP_REGISTER = 29; static constexpr u32 LR_REGISTER = 30; static constexpr u32 SP_REGISTER = 31; static constexpr u32 PC_REGISTER = 32; diff --git a/src/core/file_sys/fsmitm_romfsbuild.cpp b/src/core/file_sys/fsmitm_romfsbuild.cpp index f1d3e4129..dd9cca103 100644 --- a/src/core/file_sys/fsmitm_romfsbuild.cpp +++ b/src/core/file_sys/fsmitm_romfsbuild.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: GPL-2.0-or-later #include <cstring> +#include <span> #include <string_view> #include "common/alignment.h" #include "common/assert.h" @@ -134,7 +135,7 @@ void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir, child->size = child->source->GetSize(); - AddFile(parent, child); + AddFile(parent, std::move(child)); } for (auto& child_romfs_dir : romfs_dir->GetSubdirectories()) { @@ -163,36 +164,24 @@ void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir, bool RomFSBuildContext::AddDirectory(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx, std::shared_ptr<RomFSBuildDirectoryContext> dir_ctx) { - // Check whether it's already in the known directories. - const auto [it, is_new] = directories.emplace(dir_ctx->path, nullptr); - if (!is_new) { - return false; - } - // Add a new directory. num_dirs++; dir_table_size += sizeof(RomFSDirectoryEntry) + Common::AlignUp(dir_ctx->path_len - dir_ctx->cur_path_ofs, 4); - dir_ctx->parent = parent_dir_ctx; - it->second = dir_ctx; + dir_ctx->parent = std::move(parent_dir_ctx); + directories.emplace_back(std::move(dir_ctx)); return true; } bool RomFSBuildContext::AddFile(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx, std::shared_ptr<RomFSBuildFileContext> file_ctx) { - // Check whether it's already in the known files. - const auto [it, is_new] = files.emplace(file_ctx->path, nullptr); - if (!is_new) { - return false; - } - // Add a new file. num_files++; file_table_size += sizeof(RomFSFileEntry) + Common::AlignUp(file_ctx->path_len - file_ctx->cur_path_ofs, 4); - file_ctx->parent = parent_dir_ctx; - it->second = file_ctx; + file_ctx->parent = std::move(parent_dir_ctx); + files.emplace_back(std::move(file_ctx)); return true; } @@ -201,7 +190,7 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_) : base(std::move(base_)), ext(std::move(ext_)) { root = std::make_shared<RomFSBuildDirectoryContext>(); root->path = "\0"; - directories.emplace(root->path, root); + directories.emplace_back(root); num_dirs = 1; dir_table_size = 0x18; @@ -210,28 +199,43 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_) RomFSBuildContext::~RomFSBuildContext() = default; -std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { +std::vector<std::pair<u64, VirtualFile>> RomFSBuildContext::Build() { const u64 dir_hash_table_entry_count = romfs_get_hash_table_count(num_dirs); const u64 file_hash_table_entry_count = romfs_get_hash_table_count(num_files); dir_hash_table_size = 4 * dir_hash_table_entry_count; file_hash_table_size = 4 * file_hash_table_entry_count; - // Assign metadata pointers + // Assign metadata pointers. RomFSHeader header{}; - std::vector<u32> dir_hash_table(dir_hash_table_entry_count, ROMFS_ENTRY_EMPTY); - std::vector<u32> file_hash_table(file_hash_table_entry_count, ROMFS_ENTRY_EMPTY); - - std::vector<u8> dir_table(dir_table_size); - std::vector<u8> file_table(file_table_size); - - std::shared_ptr<RomFSBuildFileContext> cur_file; + std::vector<u8> metadata(file_hash_table_size + file_table_size + dir_hash_table_size + + dir_table_size); + u32* const dir_hash_table_pointer = reinterpret_cast<u32*>(metadata.data()); + u8* const dir_table_pointer = metadata.data() + dir_hash_table_size; + u32* const file_hash_table_pointer = + reinterpret_cast<u32*>(metadata.data() + dir_hash_table_size + dir_table_size); + u8* const file_table_pointer = + metadata.data() + dir_hash_table_size + dir_table_size + file_hash_table_size; + + std::span<u32> dir_hash_table(dir_hash_table_pointer, dir_hash_table_entry_count); + std::span<u32> file_hash_table(file_hash_table_pointer, file_hash_table_entry_count); + std::span<u8> dir_table(dir_table_pointer, dir_table_size); + std::span<u8> file_table(file_table_pointer, file_table_size); + + // Initialize hash tables. + std::memset(dir_hash_table.data(), 0xFF, dir_hash_table.size_bytes()); + std::memset(file_hash_table.data(), 0xFF, file_hash_table.size_bytes()); + + // Sort tables by name. + std::sort(files.begin(), files.end(), + [](const auto& a, const auto& b) { return a->path < b->path; }); + std::sort(directories.begin(), directories.end(), + [](const auto& a, const auto& b) { return a->path < b->path; }); // Determine file offsets. u32 entry_offset = 0; std::shared_ptr<RomFSBuildFileContext> prev_file = nullptr; - for (const auto& it : files) { - cur_file = it.second; + for (const auto& cur_file : files) { file_partition_size = Common::AlignUp(file_partition_size, 16); cur_file->offset = file_partition_size; file_partition_size += cur_file->size; @@ -243,34 +247,48 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { } // Assign deferred parent/sibling ownership. for (auto it = files.rbegin(); it != files.rend(); ++it) { - cur_file = it->second; + auto& cur_file = *it; cur_file->sibling = cur_file->parent->file; cur_file->parent->file = cur_file; } - std::shared_ptr<RomFSBuildDirectoryContext> cur_dir; - // Determine directory offsets. entry_offset = 0; - for (const auto& it : directories) { - cur_dir = it.second; + for (const auto& cur_dir : directories) { cur_dir->entry_offset = entry_offset; entry_offset += static_cast<u32>(sizeof(RomFSDirectoryEntry) + Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4)); } // Assign deferred parent/sibling ownership. - for (auto it = directories.rbegin(); it->second != root; ++it) { - cur_dir = it->second; + for (auto it = directories.rbegin(); (*it) != root; ++it) { + auto& cur_dir = *it; cur_dir->sibling = cur_dir->parent->child; cur_dir->parent->child = cur_dir; } - std::multimap<u64, VirtualFile> out; + // Create output map. + std::vector<std::pair<u64, VirtualFile>> out; + out.reserve(num_files + 2); + + // Set header fields. + header.header_size = sizeof(RomFSHeader); + header.file_hash_table_size = file_hash_table_size; + header.file_table_size = file_table_size; + header.dir_hash_table_size = dir_hash_table_size; + header.dir_table_size = dir_table_size; + header.file_partition_ofs = ROMFS_FILEPARTITION_OFS; + header.dir_hash_table_ofs = Common::AlignUp(header.file_partition_ofs + file_partition_size, 4); + header.dir_table_ofs = header.dir_hash_table_ofs + header.dir_hash_table_size; + header.file_hash_table_ofs = header.dir_table_ofs + header.dir_table_size; + header.file_table_ofs = header.file_hash_table_ofs + header.file_hash_table_size; + + std::vector<u8> header_data(sizeof(RomFSHeader)); + std::memcpy(header_data.data(), &header, header_data.size()); + out.emplace_back(0, std::make_shared<VectorVfsFile>(std::move(header_data))); // Populate file tables. - for (const auto& it : files) { - cur_file = it.second; + for (const auto& cur_file : files) { RomFSFileEntry cur_entry{}; cur_entry.parent = cur_file->parent->entry_offset; @@ -287,7 +305,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { cur_entry.name_size = name_size; - out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source)); + out.emplace_back(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source)); std::memcpy(file_table.data() + cur_file->entry_offset, &cur_entry, sizeof(RomFSFileEntry)); std::memset(file_table.data() + cur_file->entry_offset + sizeof(RomFSFileEntry), 0, Common::AlignUp(cur_entry.name_size, 4)); @@ -296,8 +314,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { } // Populate dir tables. - for (const auto& it : directories) { - cur_dir = it.second; + for (const auto& cur_dir : directories) { RomFSDirectoryEntry cur_entry{}; cur_entry.parent = cur_dir == root ? 0 : cur_dir->parent->entry_offset; @@ -323,34 +340,13 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { cur_dir->path.data() + cur_dir->cur_path_ofs, name_size); } - // Set header fields. - header.header_size = sizeof(RomFSHeader); - header.file_hash_table_size = file_hash_table_size; - header.file_table_size = file_table_size; - header.dir_hash_table_size = dir_hash_table_size; - header.dir_table_size = dir_table_size; - header.file_partition_ofs = ROMFS_FILEPARTITION_OFS; - header.dir_hash_table_ofs = Common::AlignUp(header.file_partition_ofs + file_partition_size, 4); - header.dir_table_ofs = header.dir_hash_table_ofs + header.dir_hash_table_size; - header.file_hash_table_ofs = header.dir_table_ofs + header.dir_table_size; - header.file_table_ofs = header.file_hash_table_ofs + header.file_hash_table_size; - - std::vector<u8> header_data(sizeof(RomFSHeader)); - std::memcpy(header_data.data(), &header, header_data.size()); - out.emplace(0, std::make_shared<VectorVfsFile>(std::move(header_data))); + // Write metadata. + out.emplace_back(header.dir_hash_table_ofs, + std::make_shared<VectorVfsFile>(std::move(metadata))); - std::vector<u8> metadata(file_hash_table_size + file_table_size + dir_hash_table_size + - dir_table_size); - std::size_t index = 0; - std::memcpy(metadata.data(), dir_hash_table.data(), dir_hash_table.size() * sizeof(u32)); - index += dir_hash_table.size() * sizeof(u32); - std::memcpy(metadata.data() + index, dir_table.data(), dir_table.size()); - index += dir_table.size(); - std::memcpy(metadata.data() + index, file_hash_table.data(), - file_hash_table.size() * sizeof(u32)); - index += file_hash_table.size() * sizeof(u32); - std::memcpy(metadata.data() + index, file_table.data(), file_table.size()); - out.emplace(header.dir_hash_table_ofs, std::make_shared<VectorVfsFile>(std::move(metadata))); + // Sort the output. + std::sort(out.begin(), out.end(), + [](const auto& a, const auto& b) { return a.first < b.first; }); return out; } diff --git a/src/core/file_sys/fsmitm_romfsbuild.h b/src/core/file_sys/fsmitm_romfsbuild.h index 06e5d5a47..f387c79f1 100644 --- a/src/core/file_sys/fsmitm_romfsbuild.h +++ b/src/core/file_sys/fsmitm_romfsbuild.h @@ -22,14 +22,14 @@ public: ~RomFSBuildContext(); // This finalizes the context. - std::multimap<u64, VirtualFile> Build(); + std::vector<std::pair<u64, VirtualFile>> Build(); private: VirtualDir base; VirtualDir ext; std::shared_ptr<RomFSBuildDirectoryContext> root; - std::map<std::string, std::shared_ptr<RomFSBuildDirectoryContext>, std::less<>> directories; - std::map<std::string, std::shared_ptr<RomFSBuildFileContext>, std::less<>> files; + std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> directories; + std::vector<std::shared_ptr<RomFSBuildFileContext>> files; u64 num_dirs = 0; u64 num_files = 0; u64 dir_table_size = 0; diff --git a/src/core/file_sys/romfs.cpp b/src/core/file_sys/romfs.cpp index 6de2103a0..6182598ae 100644 --- a/src/core/file_sys/romfs.cpp +++ b/src/core/file_sys/romfs.cpp @@ -55,44 +55,68 @@ struct FileEntry { }; static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect size."); -template <typename Entry> -std::pair<Entry, std::string> GetEntry(const VirtualFile& file, std::size_t offset) { - Entry entry{}; - if (file->ReadObject(&entry, offset) != sizeof(Entry)) - return {}; - std::string string(entry.name_length, '\0'); - if (file->ReadArray(&string[0], string.size(), offset + sizeof(Entry)) != string.size()) +struct RomFSTraversalContext { + RomFSHeader header; + VirtualFile file; + std::vector<u8> directory_meta; + std::vector<u8> file_meta; +}; + +template <typename EntryType, auto Member> +std::pair<EntryType, std::string> GetEntry(const RomFSTraversalContext& ctx, size_t offset) { + const size_t entry_end = offset + sizeof(EntryType); + const std::vector<u8>& vec = ctx.*Member; + const size_t size = vec.size(); + const u8* data = vec.data(); + EntryType entry{}; + + if (entry_end > size) { return {}; - return {entry, string}; + } + std::memcpy(&entry, data + offset, sizeof(EntryType)); + + const size_t name_length = std::min(entry_end + entry.name_length, size) - entry_end; + std::string name(reinterpret_cast<const char*>(data + entry_end), name_length); + + return {entry, std::move(name)}; +} + +std::pair<DirectoryEntry, std::string> GetDirectoryEntry(const RomFSTraversalContext& ctx, + size_t directory_offset) { + return GetEntry<DirectoryEntry, &RomFSTraversalContext::directory_meta>(ctx, directory_offset); +} + +std::pair<FileEntry, std::string> GetFileEntry(const RomFSTraversalContext& ctx, + size_t file_offset) { + return GetEntry<FileEntry, &RomFSTraversalContext::file_meta>(ctx, file_offset); } -void ProcessFile(const VirtualFile& file, std::size_t file_offset, std::size_t data_offset, - u32 this_file_offset, std::shared_ptr<VectorVfsDirectory>& parent) { +void ProcessFile(const RomFSTraversalContext& ctx, u32 this_file_offset, + std::shared_ptr<VectorVfsDirectory>& parent) { while (this_file_offset != ROMFS_ENTRY_EMPTY) { - auto entry = GetEntry<FileEntry>(file, file_offset + this_file_offset); + auto entry = GetFileEntry(ctx, this_file_offset); - parent->AddFile(std::make_shared<OffsetVfsFile>( - file, entry.first.size, entry.first.offset + data_offset, entry.second)); + parent->AddFile(std::make_shared<OffsetVfsFile>(ctx.file, entry.first.size, + entry.first.offset + ctx.header.data_offset, + std::move(entry.second))); this_file_offset = entry.first.sibling; } } -void ProcessDirectory(const VirtualFile& file, std::size_t dir_offset, std::size_t file_offset, - std::size_t data_offset, u32 this_dir_offset, +void ProcessDirectory(const RomFSTraversalContext& ctx, u32 this_dir_offset, std::shared_ptr<VectorVfsDirectory>& parent) { while (this_dir_offset != ROMFS_ENTRY_EMPTY) { - auto entry = GetEntry<DirectoryEntry>(file, dir_offset + this_dir_offset); + auto entry = GetDirectoryEntry(ctx, this_dir_offset); auto current = std::make_shared<VectorVfsDirectory>( std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, entry.second); if (entry.first.child_file != ROMFS_ENTRY_EMPTY) { - ProcessFile(file, file_offset, data_offset, entry.first.child_file, current); + ProcessFile(ctx, entry.first.child_file, current); } if (entry.first.child_dir != ROMFS_ENTRY_EMPTY) { - ProcessDirectory(file, dir_offset, file_offset, data_offset, entry.first.child_dir, - current); + ProcessDirectory(ctx, entry.first.child_dir, current); } parent->AddDirectory(current); @@ -107,22 +131,25 @@ VirtualDir ExtractRomFS(VirtualFile file) { return root_container; } - RomFSHeader header{}; - if (file->ReadObject(&header) != sizeof(RomFSHeader)) { - return root_container; + RomFSTraversalContext ctx{}; + + if (file->ReadObject(&ctx.header) != sizeof(RomFSHeader)) { + return nullptr; } - if (header.header_size != sizeof(RomFSHeader)) { - return root_container; + if (ctx.header.header_size != sizeof(RomFSHeader)) { + return nullptr; } - const u64 file_offset = header.file_meta.offset; - const u64 dir_offset = header.directory_meta.offset; + ctx.file = file; + ctx.directory_meta = + file->ReadBytes(ctx.header.directory_meta.size, ctx.header.directory_meta.offset); + ctx.file_meta = file->ReadBytes(ctx.header.file_meta.size, ctx.header.file_meta.offset); - ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root_container); + ProcessDirectory(ctx, 0, root_container); if (auto root = root_container->GetSubdirectory(""); root) { - return std::make_shared<CachedVfsDirectory>(std::move(root)); + return root; } ASSERT(false); diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp index a4d060007..8d5d593e8 100644 --- a/src/core/file_sys/savedata_factory.cpp +++ b/src/core/file_sys/savedata_factory.cpp @@ -12,8 +12,6 @@ namespace FileSys { -constexpr char SAVE_DATA_SIZE_FILENAME[] = ".yuzu_save_size"; - namespace { void PrintSaveDataAttributeWarnings(SaveDataAttribute meta) { @@ -197,7 +195,7 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id, GetFullPath(system, dir, SaveDataSpaceId::NandUser, type, title_id, user_id, 0); const auto relative_dir = GetOrCreateDirectoryRelative(dir, path); - const auto size_file = relative_dir->GetFile(SAVE_DATA_SIZE_FILENAME); + const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName()); if (size_file == nullptr || size_file->GetSize() < sizeof(SaveDataSize)) { return {0, 0}; } @@ -216,7 +214,7 @@ void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 us GetFullPath(system, dir, SaveDataSpaceId::NandUser, type, title_id, user_id, 0); const auto relative_dir = GetOrCreateDirectoryRelative(dir, path); - const auto size_file = relative_dir->CreateFile(SAVE_DATA_SIZE_FILENAME); + const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName()); if (size_file == nullptr) { return; } diff --git a/src/core/file_sys/savedata_factory.h b/src/core/file_sys/savedata_factory.h index 45c7c81fb..e3a0f8cef 100644 --- a/src/core/file_sys/savedata_factory.h +++ b/src/core/file_sys/savedata_factory.h @@ -83,6 +83,10 @@ struct SaveDataSize { u64 journal; }; +constexpr const char* GetSaveDataSizeFileName() { + return ".yuzu_save_size"; +} + /// File system interface to the SaveData archive class SaveDataFactory { public: diff --git a/src/core/file_sys/vfs_concat.cpp b/src/core/file_sys/vfs_concat.cpp index 168b9cbec..7c7298527 100644 --- a/src/core/file_sys/vfs_concat.cpp +++ b/src/core/file_sys/vfs_concat.cpp @@ -59,8 +59,8 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name, return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map))); } -VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::string&& name, - std::multimap<u64, VirtualFile>&& files) { +VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile( + u8 filler_byte, std::string&& name, std::vector<std::pair<u64, VirtualFile>>&& files) { // Fold trivial cases. if (files.empty()) { return nullptr; diff --git a/src/core/file_sys/vfs_concat.h b/src/core/file_sys/vfs_concat.h index cbddd12bd..b5f3d72e3 100644 --- a/src/core/file_sys/vfs_concat.h +++ b/src/core/file_sys/vfs_concat.h @@ -37,7 +37,7 @@ public: /// Convenience function that turns a map of offsets to files into a concatenated file, filling /// gaps with a given filler byte. static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name, - std::multimap<u64, VirtualFile>&& files); + std::vector<std::pair<u64, VirtualFile>>&& files); std::string GetName() const override; std::size_t GetSize() const override; diff --git a/src/core/file_sys/vfs_layered.cpp b/src/core/file_sys/vfs_layered.cpp index 08daca397..5551743fb 100644 --- a/src/core/file_sys/vfs_layered.cpp +++ b/src/core/file_sys/vfs_layered.cpp @@ -3,6 +3,7 @@ #include <algorithm> #include <set> +#include <unordered_set> #include <utility> #include "core/file_sys/vfs_layered.h" @@ -59,13 +60,12 @@ std::string LayeredVfsDirectory::GetFullPath() const { std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const { std::vector<VirtualFile> out; - std::set<std::string, std::less<>> out_names; + std::unordered_set<std::string> out_names; for (const auto& layer : dirs) { for (auto& file : layer->GetFiles()) { - auto file_name = file->GetName(); - if (!out_names.contains(file_name)) { - out_names.emplace(std::move(file_name)); + const auto [it, is_new] = out_names.emplace(file->GetName()); + if (is_new) { out.emplace_back(std::move(file)); } } @@ -75,18 +75,19 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const { } std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const { - std::vector<std::string> names; + std::vector<VirtualDir> out; + std::unordered_set<std::string> out_names; + for (const auto& layer : dirs) { for (const auto& sd : layer->GetSubdirectories()) { - if (std::find(names.begin(), names.end(), sd->GetName()) == names.end()) - names.push_back(sd->GetName()); + out_names.emplace(sd->GetName()); } } - std::vector<VirtualDir> out; - out.reserve(names.size()); - for (const auto& subdir : names) + out.reserve(out_names.size()); + for (const auto& subdir : out_names) { out.emplace_back(GetSubdirectory(subdir)); + } return out; } diff --git a/src/core/hid/input_interpreter.cpp b/src/core/hid/input_interpreter.cpp index a6bdd28f2..072f38a68 100644 --- a/src/core/hid/input_interpreter.cpp +++ b/src/core/hid/input_interpreter.cpp @@ -20,6 +20,9 @@ InputInterpreter::InputInterpreter(Core::System& system) InputInterpreter::~InputInterpreter() = default; void InputInterpreter::PollInput() { + if (npad == nullptr) { + return; + } const auto button_state = npad->GetAndResetPressState(); previous_index = current_index; diff --git a/src/core/hle/kernel/k_client_port.cpp b/src/core/hle/kernel/k_client_port.cpp index 40e09e532..11b1b977e 100644 --- a/src/core/hle/kernel/k_client_port.cpp +++ b/src/core/hle/kernel/k_client_port.cpp @@ -3,6 +3,7 @@ #include "common/scope_exit.h" #include "core/hle/kernel/k_client_port.h" +#include "core/hle/kernel/k_light_session.h" #include "core/hle/kernel/k_port.h" #include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/k_scoped_resource_reservation.h" @@ -63,6 +64,7 @@ Result KClientPort::CreateSession(KClientSession** out) { R_UNLESS(session_reservation.Succeeded(), ResultLimitReached); // Allocate a session normally. + // TODO: Dynamic resource limits session = KSession::Create(m_kernel); // Check that we successfully created a session. @@ -119,4 +121,71 @@ Result KClientPort::CreateSession(KClientSession** out) { R_SUCCEED(); } +Result KClientPort::CreateLightSession(KLightClientSession** out) { + // Declare the session we're going to allocate. + KLightSession* session{}; + + // Reserve a new session from the resource limit. + KScopedResourceReservation session_reservation(GetCurrentProcessPointer(m_kernel), + Svc::LimitableResource::SessionCountMax); + R_UNLESS(session_reservation.Succeeded(), ResultLimitReached); + + // Allocate a session normally. + // TODO: Dynamic resource limits + session = KLightSession::Create(m_kernel); + + // Check that we successfully created a session. + R_UNLESS(session != nullptr, ResultOutOfResource); + + // Update the session counts. + { + ON_RESULT_FAILURE { + session->Close(); + }; + + // Atomically increment the number of sessions. + s32 new_sessions; + { + const auto max = m_max_sessions; + auto cur_sessions = m_num_sessions.load(std::memory_order_acquire); + do { + R_UNLESS(cur_sessions < max, ResultOutOfSessions); + new_sessions = cur_sessions + 1; + } while (!m_num_sessions.compare_exchange_weak(cur_sessions, new_sessions, + std::memory_order_relaxed)); + } + + // Atomically update the peak session tracking. + { + auto peak = m_peak_sessions.load(std::memory_order_acquire); + do { + if (peak >= new_sessions) { + break; + } + } while (!m_peak_sessions.compare_exchange_weak(peak, new_sessions, + std::memory_order_relaxed)); + } + } + + // Initialize the session. + session->Initialize(this, m_parent->GetName()); + + // Commit the session reservation. + session_reservation.Commit(); + + // Register the session. + KLightSession::Register(m_kernel, session); + ON_RESULT_FAILURE { + session->GetClientSession().Close(); + session->GetServerSession().Close(); + }; + + // Enqueue the session with our parent. + R_TRY(m_parent->EnqueueSession(std::addressof(session->GetServerSession()))); + + // We succeeded, so set the output. + *out = std::addressof(session->GetClientSession()); + R_SUCCEED(); +} + } // namespace Kernel diff --git a/src/core/hle/kernel/k_client_port.h b/src/core/hle/kernel/k_client_port.h index 23db06ddf..28b332608 100644 --- a/src/core/hle/kernel/k_client_port.h +++ b/src/core/hle/kernel/k_client_port.h @@ -11,6 +11,7 @@ namespace Kernel { +class KLightClientSession; class KClientSession; class KernelCore; class KPort; @@ -51,6 +52,7 @@ public: bool IsSignaled() const override; Result CreateSession(KClientSession** out); + Result CreateLightSession(KLightClientSession** out); private: std::atomic<s32> m_num_sessions{}; diff --git a/src/core/hle/kernel/k_client_session.cpp b/src/core/hle/kernel/k_client_session.cpp index 72b66270d..472e8571c 100644 --- a/src/core/hle/kernel/k_client_session.cpp +++ b/src/core/hle/kernel/k_client_session.cpp @@ -10,9 +10,7 @@ namespace Kernel { -static constexpr u32 MessageBufferSize = 0x100; - -KClientSession::KClientSession(KernelCore& kernel) : KAutoObjectWithSlabHeapAndContainer{kernel} {} +KClientSession::KClientSession(KernelCore& kernel) : KAutoObject{kernel} {} KClientSession::~KClientSession() = default; void KClientSession::Destroy() { @@ -22,18 +20,30 @@ void KClientSession::Destroy() { void KClientSession::OnServerClosed() {} -Result KClientSession::SendSyncRequest() { +Result KClientSession::SendSyncRequest(uintptr_t address, size_t size) { + // Create a session request. + KSessionRequest* request = KSessionRequest::Create(m_kernel); + R_UNLESS(request != nullptr, ResultOutOfResource); + SCOPE_EXIT({ request->Close(); }); + + // Initialize the request. + request->Initialize(nullptr, address, size); + + // Send the request. + R_RETURN(m_parent->OnRequest(request)); +} + +Result KClientSession::SendAsyncRequest(KEvent* event, uintptr_t address, size_t size) { // Create a session request. KSessionRequest* request = KSessionRequest::Create(m_kernel); R_UNLESS(request != nullptr, ResultOutOfResource); SCOPE_EXIT({ request->Close(); }); // Initialize the request. - request->Initialize(nullptr, GetInteger(GetCurrentThread(m_kernel).GetTlsAddress()), - MessageBufferSize); + request->Initialize(event, address, size); // Send the request. - R_RETURN(m_parent->GetServerSession().OnRequest(request)); + R_RETURN(m_parent->OnRequest(request)); } } // namespace Kernel diff --git a/src/core/hle/kernel/k_client_session.h b/src/core/hle/kernel/k_client_session.h index 9b62e55e4..a39213e17 100644 --- a/src/core/hle/kernel/k_client_session.h +++ b/src/core/hle/kernel/k_client_session.h @@ -9,24 +9,12 @@ #include "core/hle/kernel/slab_helpers.h" #include "core/hle/result.h" -union Result; - -namespace Core::Memory { -class Memory; -} - -namespace Core::Timing { -class CoreTiming; -} - namespace Kernel { class KernelCore; class KSession; -class KThread; -class KClientSession final - : public KAutoObjectWithSlabHeapAndContainer<KClientSession, KAutoObjectWithList> { +class KClientSession final : public KAutoObject { KERNEL_AUTOOBJECT_TRAITS(KClientSession, KAutoObject); public: @@ -39,13 +27,13 @@ public: } void Destroy() override; - static void PostDestroy(uintptr_t arg) {} KSession* GetParent() const { return m_parent; } - Result SendSyncRequest(); + Result SendSyncRequest(uintptr_t address, size_t size); + Result SendAsyncRequest(KEvent* event, uintptr_t address, size_t size); void OnServerClosed(); diff --git a/src/core/hle/kernel/k_light_client_session.cpp b/src/core/hle/kernel/k_light_client_session.cpp new file mode 100644 index 000000000..8ce3e1ae4 --- /dev/null +++ b/src/core/hle/kernel/k_light_client_session.cpp @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_session.h" +#include "core/hle/kernel/k_thread.h" + +namespace Kernel { + +KLightClientSession::KLightClientSession(KernelCore& kernel) : KAutoObject(kernel) {} + +KLightClientSession::~KLightClientSession() = default; + +void KLightClientSession::Destroy() { + m_parent->OnClientClosed(); +} + +void KLightClientSession::OnServerClosed() {} + +Result KLightClientSession::SendSyncRequest(u32* data) { + // Get the request thread. + KThread* cur_thread = GetCurrentThreadPointer(m_kernel); + + // Set the light data. + cur_thread->SetLightSessionData(data); + + // Send the request. + R_RETURN(m_parent->OnRequest(cur_thread)); +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_client_session.h b/src/core/hle/kernel/k_light_client_session.h new file mode 100644 index 000000000..881a15cbd --- /dev/null +++ b/src/core/hle/kernel/k_light_client_session.h @@ -0,0 +1,39 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "core/hle/kernel/k_auto_object.h" +#include "core/hle/result.h" + +namespace Kernel { + +class KLightSession; + +class KLightClientSession final : public KAutoObject { + KERNEL_AUTOOBJECT_TRAITS(KLightClientSession, KAutoObject); + +public: + explicit KLightClientSession(KernelCore& kernel); + ~KLightClientSession(); + + void Initialize(KLightSession* parent) { + // Set member variables. + m_parent = parent; + } + + virtual void Destroy() override; + + const KLightSession* GetParent() const { + return m_parent; + } + + Result SendSyncRequest(u32* data); + + void OnServerClosed(); + +private: + KLightSession* m_parent; +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_server_session.cpp b/src/core/hle/kernel/k_light_server_session.cpp new file mode 100644 index 000000000..e5ceb01f2 --- /dev/null +++ b/src/core/hle/kernel/k_light_server_session.cpp @@ -0,0 +1,247 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/k_light_session.h" +#include "core/hle/kernel/k_thread.h" +#include "core/hle/kernel/k_thread_queue.h" +#include "core/hle/kernel/svc_results.h" + +namespace Kernel { + +namespace { + +constexpr u64 InvalidThreadId = std::numeric_limits<u64>::max(); + +class ThreadQueueImplForKLightServerSessionRequest final : public KThreadQueue { +private: + KThread::WaiterList* m_wait_list; + +public: + ThreadQueueImplForKLightServerSessionRequest(KernelCore& kernel, KThread::WaiterList* wl) + : KThreadQueue(kernel), m_wait_list(wl) {} + + virtual void EndWait(KThread* waiting_thread, Result wait_result) override { + // Remove the thread from our wait list. + m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread)); + + // Invoke the base end wait handler. + KThreadQueue::EndWait(waiting_thread, wait_result); + } + + virtual void CancelWait(KThread* waiting_thread, Result wait_result, + bool cancel_timer_task) override { + // Remove the thread from our wait list. + m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread)); + + // Invoke the base cancel wait handler. + KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task); + } +}; + +class ThreadQueueImplForKLightServerSessionReceive final : public KThreadQueue { +private: + KThread** m_server_thread; + +public: + ThreadQueueImplForKLightServerSessionReceive(KernelCore& kernel, KThread** st) + : KThreadQueue(kernel), m_server_thread(st) {} + + virtual void EndWait(KThread* waiting_thread, Result wait_result) override { + // Clear the server thread. + *m_server_thread = nullptr; + + // Set the waiting thread as not cancelable. + waiting_thread->ClearCancellable(); + + // Invoke the base end wait handler. + KThreadQueue::EndWait(waiting_thread, wait_result); + } + + virtual void CancelWait(KThread* waiting_thread, Result wait_result, + bool cancel_timer_task) override { + // Clear the server thread. + *m_server_thread = nullptr; + + // Set the waiting thread as not cancelable. + waiting_thread->ClearCancellable(); + + // Invoke the base cancel wait handler. + KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task); + } +}; + +} // namespace + +KLightServerSession::KLightServerSession(KernelCore& kernel) : KAutoObject(kernel) {} +KLightServerSession::~KLightServerSession() = default; + +void KLightServerSession::Destroy() { + this->CleanupRequests(); + + m_parent->OnServerClosed(); +} + +void KLightServerSession::OnClientClosed() { + this->CleanupRequests(); +} + +Result KLightServerSession::OnRequest(KThread* request_thread) { + ThreadQueueImplForKLightServerSessionRequest wait_queue(m_kernel, + std::addressof(m_request_list)); + + // Send the request. + { + // Lock the scheduler. + KScopedSchedulerLock sl(m_kernel); + + // Check that the server isn't closed. + R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed); + + // Check that the request thread isn't terminating. + R_UNLESS(!request_thread->IsTerminationRequested(), ResultTerminationRequested); + + // Add the request thread to our list. + m_request_list.push_back(*request_thread); + + // Begin waiting on the request. + request_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC); + request_thread->BeginWait(std::addressof(wait_queue)); + + // If we have a server thread, end its wait. + if (m_server_thread != nullptr) { + m_server_thread->EndWait(ResultSuccess); + } + } + + // NOTE: Nintendo returns GetCurrentThread().GetWaitResult() here. + // This is technically incorrect, although it doesn't cause problems in practice + // because this is only ever called with request_thread = GetCurrentThreadPointer(). + R_RETURN(request_thread->GetWaitResult()); +} + +Result KLightServerSession::ReplyAndReceive(u32* data) { + // Set the server context. + GetCurrentThread(m_kernel).SetLightSessionData(data); + + // Reply, if we need to. + if (data[0] & KLightSession::ReplyFlag) { + KScopedSchedulerLock sl(m_kernel); + + // Check that we're open. + R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed); + R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed); + + // Check that we have a request to reply to. + R_UNLESS(m_current_request != nullptr, ResultInvalidState); + + // Check that the server thread id is correct. + R_UNLESS(m_server_thread_id == GetCurrentThread(m_kernel).GetId(), ResultInvalidState); + + // If we can reply, do so. + if (!m_current_request->IsTerminationRequested()) { + std::memcpy(m_current_request->GetLightSessionData(), + GetCurrentThread(m_kernel).GetLightSessionData(), KLightSession::DataSize); + m_current_request->EndWait(ResultSuccess); + } + + // Close our current request. + m_current_request->Close(); + + // Clear our current request. + m_current_request = nullptr; + m_server_thread_id = InvalidThreadId; + } + + // Create the wait queue for our receive. + ThreadQueueImplForKLightServerSessionReceive wait_queue(m_kernel, + std::addressof(m_server_thread)); + + // Receive. + while (true) { + // Try to receive a request. + { + KScopedSchedulerLock sl(m_kernel); + + // Check that we aren't already receiving. + R_UNLESS(m_server_thread == nullptr, ResultInvalidState); + R_UNLESS(m_server_thread_id == InvalidThreadId, ResultInvalidState); + + // Check that we're open. + R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed); + R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed); + + // Check that we're not terminating. + R_UNLESS(!GetCurrentThread(m_kernel).IsTerminationRequested(), + ResultTerminationRequested); + + // If we have a request available, use it. + if (auto head = m_request_list.begin(); head != m_request_list.end()) { + // Set our current request. + m_current_request = std::addressof(*head); + m_current_request->Open(); + + // Set our server thread id. + m_server_thread_id = GetCurrentThread(m_kernel).GetId(); + + // Copy the client request data. + std::memcpy(GetCurrentThread(m_kernel).GetLightSessionData(), + m_current_request->GetLightSessionData(), KLightSession::DataSize); + + // We successfully received. + R_SUCCEED(); + } + + // We need to wait for a request to come in. + + // Check if we were cancelled. + if (GetCurrentThread(m_kernel).IsWaitCancelled()) { + GetCurrentThread(m_kernel).ClearWaitCancelled(); + R_THROW(ResultCancelled); + } + + // Mark ourselves as cancellable. + GetCurrentThread(m_kernel).SetCancellable(); + + // Wait for a request to come in. + m_server_thread = GetCurrentThreadPointer(m_kernel); + GetCurrentThread(m_kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC); + GetCurrentThread(m_kernel).BeginWait(std::addressof(wait_queue)); + } + + // We waited to receive a request; if our wait failed, return the failing result. + R_TRY(GetCurrentThread(m_kernel).GetWaitResult()); + } +} + +void KLightServerSession::CleanupRequests() { + // Cleanup all pending requests. + { + KScopedSchedulerLock sl(m_kernel); + + // Handle the current request. + if (m_current_request != nullptr) { + // Reply to the current request. + if (!m_current_request->IsTerminationRequested()) { + m_current_request->EndWait(ResultSessionClosed); + } + + // Clear our current request. + m_current_request->Close(); + m_current_request = nullptr; + m_server_thread_id = InvalidThreadId; + } + + // Reply to all other requests. + for (auto& thread : m_request_list) { + thread.EndWait(ResultSessionClosed); + } + + // Wait up our server thread, if we have one. + if (m_server_thread != nullptr) { + m_server_thread->EndWait(ResultSessionClosed); + } + } +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_server_session.h b/src/core/hle/kernel/k_light_server_session.h new file mode 100644 index 000000000..8eca3eab6 --- /dev/null +++ b/src/core/hle/kernel/k_light_server_session.h @@ -0,0 +1,49 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "core/hle/kernel/k_auto_object.h" +#include "core/hle/kernel/k_thread.h" +#include "core/hle/result.h" + +namespace Kernel { + +class KLightSession; + +class KLightServerSession final : public KAutoObject, + public Common::IntrusiveListBaseNode<KLightServerSession> { + KERNEL_AUTOOBJECT_TRAITS(KLightServerSession, KAutoObject); + +private: + KLightSession* m_parent{}; + KThread::WaiterList m_request_list{}; + KThread* m_current_request{}; + u64 m_server_thread_id{std::numeric_limits<u64>::max()}; + KThread* m_server_thread{}; + +public: + explicit KLightServerSession(KernelCore& kernel); + ~KLightServerSession(); + + void Initialize(KLightSession* parent) { + // Set member variables. */ + m_parent = parent; + } + + virtual void Destroy() override; + + constexpr const KLightSession* GetParent() const { + return m_parent; + } + + Result OnRequest(KThread* request_thread); + Result ReplyAndReceive(u32* data); + + void OnClientClosed(); + +private: + void CleanupRequests(); +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_session.cpp b/src/core/hle/kernel/k_light_session.cpp new file mode 100644 index 000000000..d8b1e6958 --- /dev/null +++ b/src/core/hle/kernel/k_light_session.cpp @@ -0,0 +1,81 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/kernel/k_client_port.h" +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/k_light_session.h" +#include "core/hle/kernel/k_process.h" + +namespace Kernel { + +KLightSession::KLightSession(KernelCore& kernel) + : KAutoObjectWithSlabHeapAndContainer(kernel), m_server(kernel), m_client(kernel) {} +KLightSession::~KLightSession() = default; + +void KLightSession::Initialize(KClientPort* client_port, uintptr_t name) { + // Increment reference count. + // Because reference count is one on creation, this will result + // in a reference count of two. Thus, when both server and client are closed + // this object will be destroyed. + this->Open(); + + // Create our sub sessions. + KAutoObject::Create(std::addressof(m_server)); + KAutoObject::Create(std::addressof(m_client)); + + // Initialize our sub sessions. + m_server.Initialize(this); + m_client.Initialize(this); + + // Set state and name. + m_state = State::Normal; + m_name = name; + + // Set our owner process. + m_process = GetCurrentProcessPointer(m_kernel); + m_process->Open(); + + // Set our port. + m_port = client_port; + if (m_port != nullptr) { + m_port->Open(); + } + + // Mark initialized. + m_initialized = true; +} + +void KLightSession::Finalize() { + if (m_port != nullptr) { + m_port->OnSessionFinalized(); + m_port->Close(); + } +} + +void KLightSession::OnServerClosed() { + if (m_state == State::Normal) { + m_state = State::ServerClosed; + m_client.OnServerClosed(); + } + + this->Close(); +} + +void KLightSession::OnClientClosed() { + if (m_state == State::Normal) { + m_state = State::ClientClosed; + m_server.OnClientClosed(); + } + + this->Close(); +} + +void KLightSession::PostDestroy(uintptr_t arg) { + // Release the session count resource the owner process holds. + KProcess* owner = reinterpret_cast<KProcess*>(arg); + owner->ReleaseResource(Svc::LimitableResource::SessionCountMax, 1); + owner->Close(); +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_session.h b/src/core/hle/kernel/k_light_session.h new file mode 100644 index 000000000..f78d8e689 --- /dev/null +++ b/src/core/hle/kernel/k_light_session.h @@ -0,0 +1,86 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/slab_helpers.h" +#include "core/hle/result.h" + +namespace Kernel { + +class KClientPort; +class KProcess; + +// TODO: SupportDynamicExpansion for SlabHeap +class KLightSession final + : public KAutoObjectWithSlabHeapAndContainer<KLightSession, KAutoObjectWithList> { + KERNEL_AUTOOBJECT_TRAITS(KLightSession, KAutoObject); + +private: + enum class State : u8 { + Invalid = 0, + Normal = 1, + ClientClosed = 2, + ServerClosed = 3, + }; + +public: + static constexpr size_t DataSize = sizeof(u32) * 7; + static constexpr u32 ReplyFlag = (1U << 31); + +private: + KLightServerSession m_server; + KLightClientSession m_client; + State m_state{State::Invalid}; + KClientPort* m_port{}; + uintptr_t m_name{}; + KProcess* m_process{}; + bool m_initialized{}; + +public: + explicit KLightSession(KernelCore& kernel); + ~KLightSession(); + + void Initialize(KClientPort* client_port, uintptr_t name); + void Finalize() override; + + bool IsInitialized() const override { + return m_initialized; + } + uintptr_t GetPostDestroyArgument() const override { + return reinterpret_cast<uintptr_t>(m_process); + } + + static void PostDestroy(uintptr_t arg); + + void OnServerClosed(); + void OnClientClosed(); + + bool IsServerClosed() const { + return m_state != State::Normal; + } + bool IsClientClosed() const { + return m_state != State::Normal; + } + + Result OnRequest(KThread* request_thread) { + R_RETURN(m_server.OnRequest(request_thread)); + } + + KLightClientSession& GetClientSession() { + return m_client; + } + KLightServerSession& GetServerSession() { + return m_server; + } + const KLightClientSession& GetClientSession() const { + return m_client; + } + const KLightServerSession& GetServerSession() const { + return m_server; + } +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_memory_manager.cpp b/src/core/hle/kernel/k_memory_manager.cpp index 0a973ec8c..d6bd27296 100644 --- a/src/core/hle/kernel/k_memory_manager.cpp +++ b/src/core/hle/kernel/k_memory_manager.cpp @@ -421,8 +421,9 @@ Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32 } else { // Set all the allocated memory. for (const auto& block : *out) { - std::memset(m_system.DeviceMemory().GetPointer<void>(block.GetAddress()), fill_pattern, - block.GetSize()); + m_system.DeviceMemory().buffer.ClearBackingRegion(GetInteger(block.GetAddress()) - + Core::DramMemoryMap::Base, + block.GetSize(), fill_pattern); } } diff --git a/src/core/hle/kernel/k_page_table_base.cpp b/src/core/hle/kernel/k_page_table_base.cpp index 6691586ed..423289145 100644 --- a/src/core/hle/kernel/k_page_table_base.cpp +++ b/src/core/hle/kernel/k_page_table_base.cpp @@ -69,8 +69,21 @@ public: }; template <typename AddressType> -void InvalidateInstructionCache(Core::System& system, AddressType addr, u64 size) { - system.InvalidateCpuInstructionCacheRange(GetInteger(addr), size); +void InvalidateInstructionCache(KernelCore& kernel, AddressType addr, u64 size) { + // TODO: lock the process list + for (auto& process : kernel.GetProcessList()) { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + auto* interface = process->GetArmInterface(i); + if (interface) { + interface->InvalidateCacheRange(GetInteger(addr), size); + } + } + } +} + +void ClearBackingRegion(Core::System& system, KPhysicalAddress addr, u64 size, u32 fill_value) { + system.DeviceMemory().buffer.ClearBackingRegion(GetInteger(addr) - Core::DramMemoryMap::Base, + size, fill_value); } template <typename AddressType> @@ -1261,7 +1274,7 @@ Result KPageTableBase::UnmapCodeMemory(KProcessAddress dst_address, KProcessAddr bool reprotected_pages = false; SCOPE_EXIT({ if (reprotected_pages && any_code_pages) { - InvalidateInstructionCache(m_system, dst_address, size); + InvalidateInstructionCache(m_kernel, dst_address, size); } }); @@ -1355,8 +1368,7 @@ Result KPageTableBase::MapInsecureMemory(KProcessAddress address, size_t size) { // Clear all the newly allocated pages. for (const auto& it : pg) { - std::memset(GetHeapVirtualPointer(m_kernel, it.GetAddress()), - static_cast<u32>(m_heap_fill_value), it.GetSize()); + ClearBackingRegion(m_system, it.GetAddress(), it.GetSize(), m_heap_fill_value); } // Lock the table. @@ -1562,8 +1574,7 @@ Result KPageTableBase::AllocateAndMapPagesImpl(PageLinkedList* page_list, KProce // Clear all pages. for (const auto& it : pg) { - std::memset(GetHeapVirtualPointer(m_kernel, it.GetAddress()), - static_cast<u32>(m_heap_fill_value), it.GetSize()); + ClearBackingRegion(m_system, it.GetAddress(), it.GetSize(), m_heap_fill_value); } // Map the pages. @@ -1997,7 +2008,7 @@ Result KPageTableBase::SetProcessMemoryPermission(KProcessAddress addr, size_t s for (const auto& block : pg) { StoreDataCache(GetHeapVirtualPointer(m_kernel, block.GetAddress()), block.GetSize()); } - InvalidateInstructionCache(m_system, addr, size); + InvalidateInstructionCache(m_kernel, addr, size); } R_SUCCEED(); @@ -2151,8 +2162,7 @@ Result KPageTableBase::SetHeapSize(KProcessAddress* out, size_t size) { // Clear all the newly allocated pages. for (const auto& it : pg) { - std::memset(GetHeapVirtualPointer(m_kernel, it.GetAddress()), m_heap_fill_value, - it.GetSize()); + ClearBackingRegion(m_system, it.GetAddress(), it.GetSize(), m_heap_fill_value); } // Map the pages. @@ -3239,7 +3249,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd R_TRY(PerformCopy()); // Invalidate the instruction cache, as this svc allows modifying executable pages. - InvalidateInstructionCache(m_system, dst_address, size); + InvalidateInstructionCache(m_kernel, dst_address, size); R_SUCCEED(); } diff --git a/src/core/hle/kernel/k_port.cpp b/src/core/hle/kernel/k_port.cpp index 1621ca1d3..e5f5d8028 100644 --- a/src/core/hle/kernel/k_port.cpp +++ b/src/core/hle/kernel/k_port.cpp @@ -58,4 +58,13 @@ Result KPort::EnqueueSession(KServerSession* session) { R_SUCCEED(); } +Result KPort::EnqueueSession(KLightServerSession* session) { + KScopedSchedulerLock sl{m_kernel}; + + R_UNLESS(m_state == State::Normal, ResultPortClosed); + + m_server.EnqueueSession(session); + R_SUCCEED(); +} + } // namespace Kernel diff --git a/src/core/hle/kernel/k_port.h b/src/core/hle/kernel/k_port.h index 991be27ab..26f5f14ef 100644 --- a/src/core/hle/kernel/k_port.h +++ b/src/core/hle/kernel/k_port.h @@ -13,6 +13,7 @@ namespace Kernel { +class KLightServerSession; class KServerSession; class KPort final : public KAutoObjectWithSlabHeapAndContainer<KPort, KAutoObjectWithList> { @@ -38,6 +39,7 @@ public: bool IsServerClosed() const; Result EnqueueSession(KServerSession* session); + Result EnqueueSession(KLightServerSession* session); KClientPort& GetClientPort() { return m_client; diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp index 6c29eb72c..3a2635e1f 100644 --- a/src/core/hle/kernel/k_process.cpp +++ b/src/core/hle/kernel/k_process.cpp @@ -13,6 +13,12 @@ #include "core/hle/kernel/k_thread_queue.h" #include "core/hle/kernel/k_worker_task_manager.h" +#include "core/arm/dynarmic/arm_dynarmic_32.h" +#include "core/arm/dynarmic/arm_dynarmic_64.h" +#ifdef HAS_NCE +#include "core/arm/nce/arm_nce.h" +#endif + namespace Kernel { namespace { @@ -957,10 +963,8 @@ Result KProcess::Run(s32 priority, size_t stack_size) { R_TRY(m_handle_table.Add(std::addressof(thread_handle), main_thread)); // Set the thread arguments. - main_thread->GetContext32().cpu_registers[0] = 0; - main_thread->GetContext64().cpu_registers[0] = 0; - main_thread->GetContext32().cpu_registers[1] = thread_handle; - main_thread->GetContext64().cpu_registers[1] = thread_handle; + main_thread->GetContext().r[0] = 0; + main_thread->GetContext().r[1] = thread_handle; // Update our state. this->ChangeState((state == State::Created) ? State::Running : State::RunningAttached); @@ -1199,6 +1203,9 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std: m_is_hbl = is_hbl; m_ideal_core_id = metadata.GetMainThreadCore(); + // Set up emulation context. + this->InitializeInterfaces(); + // We succeeded. R_SUCCEED(); } @@ -1227,6 +1234,31 @@ void KProcess::LoadModule(CodeSet code_set, KProcessAddress base_addr) { #endif } +void KProcess::InitializeInterfaces() { + this->GetMemory().SetCurrentPageTable(*this); + +#ifdef HAS_NCE + if (this->Is64Bit() && Settings::IsNceEnabled()) { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + m_arm_interfaces[i] = std::make_unique<Core::ArmNce>(m_kernel.System(), true, i); + } + } else +#endif + if (this->Is64Bit()) { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + m_arm_interfaces[i] = std::make_unique<Core::ArmDynarmic64>( + m_kernel.System(), m_kernel.IsMulticore(), this, + static_cast<Core::DynarmicExclusiveMonitor&>(m_kernel.GetExclusiveMonitor()), i); + } + } else { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + m_arm_interfaces[i] = std::make_unique<Core::ArmDynarmic32>( + m_kernel.System(), m_kernel.IsMulticore(), this, + static_cast<Core::DynarmicExclusiveMonitor&>(m_kernel.GetExclusiveMonitor()), i); + } + } +} + bool KProcess::InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type) { const auto watch{std::find_if(m_watchpoints.begin(), m_watchpoints.end(), [&](const auto& wp) { return wp.type == DebugWatchpointType::None; diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.h index d8cd0fdde..4b114e39b 100644 --- a/src/core/hle/kernel/k_process.h +++ b/src/core/hle/kernel/k_process.h @@ -5,6 +5,7 @@ #include <map> +#include "core/arm/arm_interface.h" #include "core/file_sys/program_metadata.h" #include "core/hle/kernel/code_set.h" #include "core/hle/kernel/k_address_arbiter.h" @@ -106,6 +107,8 @@ private: bool m_is_suspended{}; bool m_is_immortal{}; bool m_is_handle_table_initialized{}; + std::array<std::unique_ptr<Core::ArmInterface>, Core::Hardware::NUM_CPU_CORES> + m_arm_interfaces{}; std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{}; std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{}; std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_switch_counts{}; @@ -476,6 +479,10 @@ public: } #endif + Core::ArmInterface* GetArmInterface(size_t core_index) const { + return m_arm_interfaces[core_index].get(); + } + public: // Attempts to insert a watchpoint into a free slot. Returns false if none are available. bool InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type); @@ -493,6 +500,8 @@ public: void LoadModule(CodeSet code_set, KProcessAddress base_addr); + void InitializeInterfaces(); + Core::Memory::Memory& GetMemory() const; public: diff --git a/src/core/hle/kernel/k_process_page_table.h b/src/core/hle/kernel/k_process_page_table.h index 9e40f68bc..346d7ca08 100644 --- a/src/core/hle/kernel/k_process_page_table.h +++ b/src/core/hle/kernel/k_process_page_table.h @@ -7,10 +7,6 @@ #include "core/hle/kernel/k_scoped_lock.h" #include "core/hle/kernel/svc_types.h" -namespace Core { -class ARM_Interface; -} - namespace Kernel { class KProcessPageTable { diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp index 1bce63a56..27d1c3846 100644 --- a/src/core/hle/kernel/k_scheduler.cpp +++ b/src/core/hle/kernel/k_scheduler.cpp @@ -494,12 +494,7 @@ void KScheduler::ScheduleImplFiber() { } void KScheduler::Unload(KThread* thread) { - auto& cpu_core = m_kernel.System().ArmInterface(m_core_id); - cpu_core.SaveContext(thread->GetContext32()); - cpu_core.SaveContext(thread->GetContext64()); - // Save the TPIDR_EL0 system register in case it was modified. - thread->SetTpidrEl0(cpu_core.GetTPIDR_EL0()); - cpu_core.ClearExclusiveState(); + m_kernel.PhysicalCore(m_core_id).SaveContext(thread); // Check if the thread is terminated by checking the DPC flags. if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) { @@ -509,14 +504,7 @@ void KScheduler::Unload(KThread* thread) { } void KScheduler::Reload(KThread* thread) { - auto& cpu_core = m_kernel.System().ArmInterface(m_core_id); - auto* process = thread->GetOwnerProcess(); - cpu_core.LoadContext(thread->GetContext32()); - cpu_core.LoadContext(thread->GetContext64()); - cpu_core.SetTlsAddress(GetInteger(thread->GetTlsAddress())); - cpu_core.SetTPIDR_EL0(thread->GetTpidrEl0()); - cpu_core.LoadWatchpointArray(process ? &process->GetWatchpoints() : nullptr); - cpu_core.ClearExclusiveState(); + m_kernel.PhysicalCore(m_core_id).LoadContext(thread); } void KScheduler::ClearPreviousThread(KernelCore& kernel, KThread* thread) { diff --git a/src/core/hle/kernel/k_server_port.cpp b/src/core/hle/kernel/k_server_port.cpp index a29d34bc1..bb6632f58 100644 --- a/src/core/hle/kernel/k_server_port.cpp +++ b/src/core/hle/kernel/k_server_port.cpp @@ -27,12 +27,14 @@ bool KServerPort::IsLight() const { void KServerPort::CleanupSessions() { // Ensure our preconditions are met. if (this->IsLight()) { - UNIMPLEMENTED(); + ASSERT(m_session_list.empty()); + } else { + ASSERT(m_light_session_list.empty()); } // Cleanup the session list. while (true) { - // Get the last session in the list + // Get the last session in the list. KServerSession* session = nullptr; { KScopedSchedulerLock sl{m_kernel}; @@ -49,6 +51,26 @@ void KServerPort::CleanupSessions() { break; } } + + // Cleanup the light session list. + while (true) { + // Get the last session in the list. + KLightServerSession* session = nullptr; + { + KScopedSchedulerLock sl{m_kernel}; + if (!m_light_session_list.empty()) { + session = std::addressof(m_light_session_list.front()); + m_light_session_list.pop_front(); + } + } + + // Close the session. + if (session != nullptr) { + session->Close(); + } else { + break; + } + } } void KServerPort::Destroy() { @@ -64,8 +86,7 @@ void KServerPort::Destroy() { bool KServerPort::IsSignaled() const { if (this->IsLight()) { - UNIMPLEMENTED(); - return false; + return !m_light_session_list.empty(); } else { return !m_session_list.empty(); } @@ -83,6 +104,18 @@ void KServerPort::EnqueueSession(KServerSession* session) { } } +void KServerPort::EnqueueSession(KLightServerSession* session) { + ASSERT(this->IsLight()); + + KScopedSchedulerLock sl{m_kernel}; + + // Add the session to our queue. + m_light_session_list.push_back(*session); + if (m_light_session_list.size() == 1) { + this->NotifyAvailable(); + } +} + KServerSession* KServerPort::AcceptSession() { ASSERT(!this->IsLight()); @@ -98,4 +131,19 @@ KServerSession* KServerPort::AcceptSession() { return session; } +KLightServerSession* KServerPort::AcceptLightSession() { + ASSERT(this->IsLight()); + + KScopedSchedulerLock sl{m_kernel}; + + // Return the first session in the list. + if (m_light_session_list.empty()) { + return nullptr; + } + + KLightServerSession* session = std::addressof(m_light_session_list.front()); + m_light_session_list.pop_front(); + return session; +} + } // namespace Kernel diff --git a/src/core/hle/kernel/k_server_port.h b/src/core/hle/kernel/k_server_port.h index 625280290..72fdb6734 100644 --- a/src/core/hle/kernel/k_server_port.h +++ b/src/core/hle/kernel/k_server_port.h @@ -9,6 +9,7 @@ #include "common/intrusive_list.h" +#include "core/hle/kernel/k_light_server_session.h" #include "core/hle/kernel/k_server_session.h" #include "core/hle/kernel/k_synchronization_object.h" @@ -28,8 +29,10 @@ public: void Initialize(KPort* parent); void EnqueueSession(KServerSession* session); + void EnqueueSession(KLightServerSession* session); KServerSession* AcceptSession(); + KLightServerSession* AcceptLightSession(); const KPort* GetParent() const { return m_parent; @@ -43,10 +46,12 @@ public: private: using SessionList = Common::IntrusiveListBaseTraits<KServerSession>::ListType; + using LightSessionList = Common::IntrusiveListBaseTraits<KLightServerSession>::ListType; void CleanupSessions(); SessionList m_session_list{}; + LightSessionList m_light_session_list{}; KPort* m_parent{}; }; diff --git a/src/core/hle/kernel/k_server_session.cpp b/src/core/hle/kernel/k_server_session.cpp index 3ea653163..e33a88e24 100644 --- a/src/core/hle/kernel/k_server_session.cpp +++ b/src/core/hle/kernel/k_server_session.cpp @@ -453,6 +453,11 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContext size_t client_buffer_size = request->GetSize(); // bool recv_list_broken = false; + if (!client_message) { + client_message = GetInteger(client_thread->GetTlsAddress()); + client_buffer_size = MessageBufferSize; + } + // Receive the message. Core::Memory::Memory& memory{client_thread->GetOwnerProcess()->GetMemory()}; if (out_context != nullptr) { @@ -462,8 +467,7 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContext std::make_shared<Service::HLERequestContext>(m_kernel, memory, this, client_thread); (*out_context)->SetSessionRequestManager(manager); (*out_context) - ->PopulateFromIncomingCommandBuffer(client_thread->GetOwnerProcess()->GetHandleTable(), - cmd_buf); + ->PopulateFromIncomingCommandBuffer(*client_thread->GetOwnerProcess(), cmd_buf); } else { KThread* server_thread = GetCurrentThreadPointer(m_kernel); KProcess& src_process = *client_thread->GetOwnerProcess(); diff --git a/src/core/hle/kernel/k_session.h b/src/core/hle/kernel/k_session.h index f69bab088..3f4dd5989 100644 --- a/src/core/hle/kernel/k_session.h +++ b/src/core/hle/kernel/k_session.h @@ -46,6 +46,10 @@ public: return this->GetState() != State::Normal; } + Result OnRequest(KSessionRequest* request) { + R_RETURN(m_server.OnRequest(request)); + } + KClientSession& GetClientSession() { return m_client; } diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp index a6deb50ec..7d9a6e9cf 100644 --- a/src/core/hle/kernel/k_thread.cpp +++ b/src/core/hle/kernel/k_thread.cpp @@ -41,24 +41,25 @@ namespace { constexpr inline s32 TerminatingThreadPriority = Kernel::Svc::SystemThreadPriorityHighest - 1; -static void ResetThreadContext32(Kernel::KThread::ThreadContext32& context, u32 stack_top, - u32 entry_point, u32 arg) { - context = {}; - context.cpu_registers[0] = arg; - context.cpu_registers[15] = entry_point; - context.cpu_registers[13] = stack_top; - context.fpscr = 0; -} - -static void ResetThreadContext64(Kernel::KThread::ThreadContext64& context, u64 stack_top, - u64 entry_point, u64 arg) { - context = {}; - context.cpu_registers[0] = arg; - context.cpu_registers[18] = Kernel::KSystemControl::GenerateRandomU64() | 1; - context.pc = entry_point; - context.sp = stack_top; - context.fpcr = 0; - context.fpsr = 0; +static void ResetThreadContext32(Kernel::Svc::ThreadContext& ctx, u64 stack_top, u64 entry_point, + u64 arg) { + ctx = {}; + ctx.r[0] = arg; + ctx.r[15] = entry_point; + ctx.r[13] = stack_top; + ctx.fpcr = 0; + ctx.fpsr = 0; +} + +static void ResetThreadContext64(Kernel::Svc::ThreadContext& ctx, u64 stack_top, u64 entry_point, + u64 arg) { + ctx = {}; + ctx.r[0] = arg; + ctx.r[18] = Kernel::KSystemControl::GenerateRandomU64() | 1; + ctx.pc = entry_point; + ctx.sp = stack_top; + ctx.fpcr = 0; + ctx.fpsr = 0; } } // namespace @@ -223,9 +224,11 @@ Result KThread::Initialize(KThreadFunction func, uintptr_t arg, KProcessAddress } // Initialize thread context. - ResetThreadContext64(m_thread_context_64, GetInteger(user_stack_top), GetInteger(func), arg); - ResetThreadContext32(m_thread_context_32, static_cast<u32>(GetInteger(user_stack_top)), - static_cast<u32>(GetInteger(func)), static_cast<u32>(arg)); + if (m_parent != nullptr && !m_parent->Is64Bit()) { + ResetThreadContext32(m_thread_context, GetInteger(user_stack_top), GetInteger(func), arg); + } else { + ResetThreadContext64(m_thread_context, GetInteger(user_stack_top), GetInteger(func), arg); + } // Setup the stack parameters. StackParameters& sp = this->GetStackParameters(); @@ -823,20 +826,7 @@ void KThread::CloneFpuStatus() { ASSERT(this->GetOwnerProcess() != nullptr); ASSERT(this->GetOwnerProcess() == GetCurrentProcessPointer(m_kernel)); - if (this->GetOwnerProcess()->Is64Bit()) { - // Clone FPSR and FPCR. - ThreadContext64 cur_ctx{}; - m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx); - - this->GetContext64().fpcr = cur_ctx.fpcr; - this->GetContext64().fpsr = cur_ctx.fpsr; - } else { - // Clone FPSCR. - ThreadContext32 cur_ctx{}; - m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx); - - this->GetContext32().fpscr = cur_ctx.fpscr; - } + m_kernel.CurrentPhysicalCore().CloneFpuStatus(this); } Result KThread::SetActivity(Svc::ThreadActivity activity) { @@ -912,7 +902,7 @@ Result KThread::SetActivity(Svc::ThreadActivity activity) { R_SUCCEED(); } -Result KThread::GetThreadContext3(Common::ScratchBuffer<u8>& out) { +Result KThread::GetThreadContext3(Svc::ThreadContext* out) { // Lock ourselves. KScopedLightLock lk{m_activity_pause_lock}; @@ -926,18 +916,16 @@ Result KThread::GetThreadContext3(Common::ScratchBuffer<u8>& out) { // If we're not terminating, get the thread's user context. if (!this->IsTerminationRequested()) { + *out = m_thread_context; + + // Mask away mode bits, interrupt bits, IL bit, and other reserved bits. + constexpr u32 El0Aarch64PsrMask = 0xF0000000; + constexpr u32 El0Aarch32PsrMask = 0xFE0FFE20; + if (m_parent->Is64Bit()) { - // Mask away mode bits, interrupt bits, IL bit, and other reserved bits. - auto context = GetContext64(); - context.pstate &= 0xFF0FFE20; - out.resize_destructive(sizeof(context)); - std::memcpy(out.data(), std::addressof(context), sizeof(context)); + out->pstate &= El0Aarch64PsrMask; } else { - // Mask away mode bits, interrupt bits, IL bit, and other reserved bits. - auto context = GetContext32(); - context.cpsr &= 0xFF0FFE20; - out.resize_destructive(sizeof(context)); - std::memcpy(out.data(), std::addressof(context), sizeof(context)); + out->pstate &= El0Aarch32PsrMask; } } } diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h index e9ca5dfca..e9925d231 100644 --- a/src/core/hle/kernel/k_thread.h +++ b/src/core/hle/kernel/k_thread.h @@ -38,7 +38,6 @@ namespace Core { namespace Memory { class Memory; } -class ARM_Interface; class System; } // namespace Core @@ -137,8 +136,6 @@ public: ~KThread() override; public: - using ThreadContext32 = Core::ARM_Interface::ThreadContext32; - using ThreadContext64 = Core::ARM_Interface::ThreadContext64; using WaiterList = Common::IntrusiveListBaseTraits<KThread>::ListType; /** @@ -246,31 +243,22 @@ public: * @returns The value of the TPIDR_EL0 register. */ u64 GetTpidrEl0() const { - return m_thread_context_64.tpidr; + return m_thread_context.tpidr; } /// Sets the value of the TPIDR_EL0 Read/Write system register for this thread. void SetTpidrEl0(u64 value) { - m_thread_context_64.tpidr = value; - m_thread_context_32.tpidr = static_cast<u32>(value); + m_thread_context.tpidr = value; } void CloneFpuStatus(); - ThreadContext32& GetContext32() { - return m_thread_context_32; + Svc::ThreadContext& GetContext() { + return m_thread_context; } - const ThreadContext32& GetContext32() const { - return m_thread_context_32; - } - - ThreadContext64& GetContext64() { - return m_thread_context_64; - } - - const ThreadContext64& GetContext64() const { - return m_thread_context_64; + const Svc::ThreadContext& GetContext() const { + return m_thread_context; } std::shared_ptr<Common::Fiber>& GetHostContext(); @@ -397,6 +385,13 @@ public: m_cancellable = false; } + u32* GetLightSessionData() const { + return m_light_ipc_data; + } + void SetLightSessionData(u32* data) { + m_light_ipc_data = data; + } + bool IsTerminationRequested() const { return m_termination_requested || GetRawState() == ThreadState::Terminated; } @@ -577,7 +572,7 @@ public: void RemoveWaiter(KThread* thread); - Result GetThreadContext3(Common::ScratchBuffer<u8>& out); + Result GetThreadContext3(Svc::ThreadContext* out); KThread* RemoveUserWaiterByKey(bool* out_has_waiters, KProcessAddress key) { return this->RemoveWaiterByKey(out_has_waiters, key, false); @@ -734,8 +729,7 @@ private: std::function<void()>&& init_func); // For core KThread implementation - ThreadContext32 m_thread_context_32{}; - ThreadContext64 m_thread_context_64{}; + Svc::ThreadContext m_thread_context{}; Common::IntrusiveListNode m_process_list_node; Common::IntrusiveRedBlackTreeNode m_condvar_arbiter_tree_node{}; s32 m_priority{}; diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 4a1559291..e479dacde 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -99,13 +99,6 @@ struct KernelCore::Impl { RegisterHostThread(nullptr); } - void InitializeCores() { - for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) { - cores[core_id]->Initialize((*application_process).Is64Bit()); - system.ApplicationMemory().SetCurrentPageTable(*application_process, core_id); - } - } - void TerminateApplicationProcess() { application_process.load()->Terminate(); } @@ -142,7 +135,6 @@ struct KernelCore::Impl { obj = nullptr; } }; - CleanupObject(hid_shared_mem); CleanupObject(font_shared_mem); CleanupObject(irs_shared_mem); CleanupObject(time_shared_mem); @@ -205,7 +197,7 @@ struct KernelCore::Impl { const s32 core{static_cast<s32>(i)}; schedulers[i] = std::make_unique<Kernel::KScheduler>(system.Kernel()); - cores[i] = std::make_unique<Kernel::PhysicalCore>(i, system, *schedulers[i]); + cores[i] = std::make_unique<Kernel::PhysicalCore>(system.Kernel(), i); auto* main_thread{Kernel::KThread::Create(system.Kernel())}; main_thread->SetCurrentCore(core); @@ -751,22 +743,16 @@ struct KernelCore::Impl { void InitializeHackSharedMemory(KernelCore& kernel) { // Setup memory regions for emulated processes // TODO(bunnei): These should not be hardcoded regions initialized within the kernel - constexpr std::size_t hid_size{0x40000}; constexpr std::size_t font_size{0x1100000}; constexpr std::size_t irs_size{0x8000}; constexpr std::size_t time_size{0x1000}; constexpr std::size_t hidbus_size{0x1000}; - hid_shared_mem = KSharedMemory::Create(system.Kernel()); font_shared_mem = KSharedMemory::Create(system.Kernel()); irs_shared_mem = KSharedMemory::Create(system.Kernel()); time_shared_mem = KSharedMemory::Create(system.Kernel()); hidbus_shared_mem = KSharedMemory::Create(system.Kernel()); - hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None, - Svc::MemoryPermission::Read, hid_size); - KSharedMemory::Register(kernel, hid_shared_mem); - font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None, Svc::MemoryPermission::Read, font_size); KSharedMemory::Register(kernel, font_shared_mem); @@ -880,10 +866,6 @@ void KernelCore::Initialize() { impl->Initialize(*this); } -void KernelCore::InitializeCores() { - impl->InitializeCores(); -} - void KernelCore::Shutdown() { impl->Shutdown(); } @@ -993,21 +975,6 @@ const KAutoObjectWithListContainer& KernelCore::ObjectListContainer() const { return *impl->global_object_list_container; } -void KernelCore::InvalidateAllInstructionCaches() { - for (auto& physical_core : impl->cores) { - physical_core->ArmInterface().ClearInstructionCache(); - } -} - -void KernelCore::InvalidateCpuInstructionCacheRange(KProcessAddress addr, std::size_t size) { - for (auto& physical_core : impl->cores) { - if (!physical_core->IsInitialized()) { - continue; - } - physical_core->ArmInterface().InvalidateCacheRange(GetInteger(addr), size); - } -} - void KernelCore::PrepareReschedule(std::size_t id) { // TODO: Reimplement, this } @@ -1216,14 +1183,6 @@ const KSystemResource& KernelCore::GetSystemSystemResource() const { return *impl->sys_system_resource; } -Kernel::KSharedMemory& KernelCore::GetHidSharedMem() { - return *impl->hid_shared_mem; -} - -const Kernel::KSharedMemory& KernelCore::GetHidSharedMem() const { - return *impl->hid_shared_mem; -} - Kernel::KSharedMemory& KernelCore::GetFontSharedMem() { return *impl->font_shared_mem; } @@ -1366,6 +1325,7 @@ struct KernelCore::SlabHeapContainer { KSlabHeap<KProcess> process; KSlabHeap<KResourceLimit> resource_limit; KSlabHeap<KSession> session; + KSlabHeap<KLightSession> light_session; KSlabHeap<KSharedMemory> shared_memory; KSlabHeap<KSharedMemoryInfo> shared_memory_info; KSlabHeap<KThread> thread; @@ -1396,6 +1356,8 @@ KSlabHeap<T>& KernelCore::SlabHeap() { return slab_heap_container->resource_limit; } else if constexpr (std::is_same_v<T, KSession>) { return slab_heap_container->session; + } else if constexpr (std::is_same_v<T, KLightSession>) { + return slab_heap_container->light_session; } else if constexpr (std::is_same_v<T, KSharedMemory>) { return slab_heap_container->shared_memory; } else if constexpr (std::is_same_v<T, KSharedMemoryInfo>) { @@ -1433,6 +1395,7 @@ template KSlabHeap<KPort>& KernelCore::SlabHeap(); template KSlabHeap<KProcess>& KernelCore::SlabHeap(); template KSlabHeap<KResourceLimit>& KernelCore::SlabHeap(); template KSlabHeap<KSession>& KernelCore::SlabHeap(); +template KSlabHeap<KLightSession>& KernelCore::SlabHeap(); template KSlabHeap<KSharedMemory>& KernelCore::SlabHeap(); template KSlabHeap<KSharedMemoryInfo>& KernelCore::SlabHeap(); template KSlabHeap<KThread>& KernelCore::SlabHeap(); diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index d8086c0ea..78c88902c 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -104,9 +104,6 @@ public: /// Resets the kernel to a clean slate for use. void Initialize(); - /// Initializes the CPU cores. - void InitializeCores(); - /// Clears all resources in use by the kernel instance. void Shutdown(); @@ -181,10 +178,6 @@ public: const KAutoObjectWithListContainer& ObjectListContainer() const; - void InvalidateAllInstructionCaches(); - - void InvalidateCpuInstructionCacheRange(KProcessAddress addr, std::size_t size); - /// Registers all kernel objects with the global emulation state, this is purely for tracking /// leaks after emulation has been shutdown. void RegisterKernelObject(KAutoObject* object); @@ -246,12 +239,6 @@ public: /// Gets the system resource manager. const KSystemResource& GetSystemSystemResource() const; - /// Gets the shared memory object for HID services. - Kernel::KSharedMemory& GetHidSharedMem(); - - /// Gets the shared memory object for HID services. - const Kernel::KSharedMemory& GetHidSharedMem() const; - /// Gets the shared memory object for font services. Kernel::KSharedMemory& GetFontSharedMem(); diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp index 073039825..0f45a3249 100644 --- a/src/core/hle/kernel/physical_core.cpp +++ b/src/core/hle/kernel/physical_core.cpp @@ -1,62 +1,206 @@ // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "common/scope_exit.h" #include "common/settings.h" -#include "core/arm/dynarmic/arm_dynarmic_32.h" -#include "core/arm/dynarmic/arm_dynarmic_64.h" -#ifdef HAS_NCE -#include "core/arm/nce/arm_nce.h" -#endif #include "core/core.h" -#include "core/hle/kernel/k_scheduler.h" +#include "core/debugger/debugger.h" +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/physical_core.h" +#include "core/hle/kernel/svc.h" namespace Kernel { -PhysicalCore::PhysicalCore(std::size_t core_index, Core::System& system, KScheduler& scheduler) - : m_core_index{core_index}, m_system{system}, m_scheduler{scheduler} { -#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64) - // TODO(bunnei): Initialization relies on a core being available. We may later replace this with - // an NCE interface or a 32-bit instance of Dynarmic. This should be abstracted out to a CPU - // manager. - auto& kernel = system.Kernel(); - m_arm_interface = std::make_unique<Core::ARM_Dynarmic_64>( - system, kernel.IsMulticore(), - reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()), - m_core_index); -#else -#error Platform not supported yet. -#endif +PhysicalCore::PhysicalCore(KernelCore& kernel, std::size_t core_index) + : m_kernel{kernel}, m_core_index{core_index} { + m_is_single_core = !kernel.IsMulticore(); } - PhysicalCore::~PhysicalCore() = default; -void PhysicalCore::Initialize(bool is_64_bit) { -#if defined(HAS_NCE) - if (Settings::IsNceEnabled()) { - m_arm_interface = std::make_unique<Core::ARM_NCE>(m_system, m_system.Kernel().IsMulticore(), - m_core_index); +void PhysicalCore::RunThread(Kernel::KThread* thread) { + auto* process = thread->GetOwnerProcess(); + auto& system = m_kernel.System(); + auto* interface = process->GetArmInterface(m_core_index); + + interface->Initialize(); + + const auto EnterContext = [&]() { + system.EnterCPUProfile(); + + // Lock the core context. + std::scoped_lock lk{m_guard}; + + // Check if we are already interrupted. If we are, we can just stop immediately. + if (m_is_interrupted) { + return false; + } + + // Mark that we are running. + m_arm_interface = interface; + m_current_thread = thread; + + // Acquire the lock on the thread parameters. + // This allows us to force synchronization with Interrupt. + interface->LockThread(thread); + + return true; + }; + + const auto ExitContext = [&]() { + // Unlock the thread. + interface->UnlockThread(thread); + + // Lock the core context. + std::scoped_lock lk{m_guard}; + + // On exit, we no longer are running. + m_arm_interface = nullptr; + m_current_thread = nullptr; + + system.ExitCPUProfile(); + }; + + while (true) { + // If the thread is scheduled for termination, exit. + if (thread->HasDpc() && thread->IsTerminationRequested()) { + thread->Exit(); + } + + // Notify the debugger and go to sleep if a step was performed + // and this thread has been scheduled again. + if (thread->GetStepState() == StepState::StepPerformed) { + system.GetDebugger().NotifyThreadStopped(thread); + thread->RequestSuspend(SuspendType::Debug); + return; + } + + // Otherwise, run the thread. + Core::HaltReason hr{}; + { + // If we were interrupted, exit immediately. + if (!EnterContext()) { + return; + } + + if (thread->GetStepState() == StepState::StepPending) { + hr = interface->StepThread(thread); + + if (True(hr & Core::HaltReason::StepThread)) { + thread->SetStepState(StepState::StepPerformed); + } + } else { + hr = interface->RunThread(thread); + } + + ExitContext(); + } + + // Determine why we stopped. + const bool supervisor_call = True(hr & Core::HaltReason::SupervisorCall); + const bool prefetch_abort = True(hr & Core::HaltReason::PrefetchAbort); + const bool breakpoint = True(hr & Core::HaltReason::InstructionBreakpoint); + const bool data_abort = True(hr & Core::HaltReason::DataAbort); + const bool interrupt = True(hr & Core::HaltReason::BreakLoop); + + // Since scheduling may occur here, we cannot use any cached + // state after returning from calls we make. + + // Notify the debugger and go to sleep if a breakpoint was hit, + // or if the thread is unable to continue for any reason. + if (breakpoint || prefetch_abort) { + if (breakpoint) { + interface->RewindBreakpointInstruction(); + } + if (system.DebuggerEnabled()) { + system.GetDebugger().NotifyThreadStopped(thread); + } else { + interface->LogBacktrace(process); + } + thread->RequestSuspend(SuspendType::Debug); + return; + } + + // Notify the debugger and go to sleep on data abort. + if (data_abort) { + if (system.DebuggerEnabled()) { + system.GetDebugger().NotifyThreadWatchpoint(thread, *interface->HaltedWatchpoint()); + } + thread->RequestSuspend(SuspendType::Debug); + return; + } + + // Handle system calls. + if (supervisor_call) { + // Perform call. + Svc::Call(system, interface->GetSvcNumber()); + return; + } + + // Handle external interrupt sources. + if (interrupt || m_is_single_core) { + return; + } + } +} + +void PhysicalCore::LoadContext(const KThread* thread) { + auto* const process = thread->GetOwnerProcess(); + if (!process) { + // Kernel threads do not run on emulated CPU cores. return; } -#endif -#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64) - auto& kernel = m_system.Kernel(); - if (!is_64_bit) { - // We already initialized a 64-bit core, replace with a 32-bit one. - m_arm_interface = std::make_unique<Core::ARM_Dynarmic_32>( - m_system, kernel.IsMulticore(), - reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()), - m_core_index); + + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->SetContext(thread->GetContext()); + interface->SetTpidrroEl0(GetInteger(thread->GetTlsAddress())); + interface->SetWatchpointArray(&process->GetWatchpoints()); } -#else -#error Platform not supported yet. -#endif } -void PhysicalCore::Run() { - m_arm_interface->Run(); - m_arm_interface->ClearExclusiveState(); +void PhysicalCore::LoadSvcArguments(const KProcess& process, std::span<const uint64_t, 8> args) { + process.GetArmInterface(m_core_index)->SetSvcArguments(args); +} + +void PhysicalCore::SaveContext(KThread* thread) const { + auto* const process = thread->GetOwnerProcess(); + if (!process) { + // Kernel threads do not run on emulated CPU cores. + return; + } + + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->GetContext(thread->GetContext()); + } +} + +void PhysicalCore::SaveSvcArguments(KProcess& process, std::span<uint64_t, 8> args) const { + process.GetArmInterface(m_core_index)->GetSvcArguments(args); +} + +void PhysicalCore::CloneFpuStatus(KThread* dst) const { + auto* process = dst->GetOwnerProcess(); + + Svc::ThreadContext ctx{}; + process->GetArmInterface(m_core_index)->GetContext(ctx); + + dst->GetContext().fpcr = ctx.fpcr; + dst->GetContext().fpsr = ctx.fpsr; +} + +void PhysicalCore::LogBacktrace() { + auto* process = GetCurrentProcessPointer(m_kernel); + if (!process) { + return; + } + + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->LogBacktrace(process); + } } void PhysicalCore::Idle() { @@ -69,16 +213,31 @@ bool PhysicalCore::IsInterrupted() const { } void PhysicalCore::Interrupt() { - std::unique_lock lk{m_guard}; + // Lock core context. + std::scoped_lock lk{m_guard}; + + // Load members. + auto* arm_interface = m_arm_interface; + auto* thread = m_current_thread; + + // Add interrupt flag. m_is_interrupted = true; - m_arm_interface->SignalInterrupt(); - m_on_interrupt.notify_all(); + + // Interrupt ourselves. + m_on_interrupt.notify_one(); + + // If there is no thread running, we are done. + if (arm_interface == nullptr) { + return; + } + + // Interrupt the CPU. + arm_interface->SignalInterrupt(thread); } void PhysicalCore::ClearInterrupt() { - std::unique_lock lk{m_guard}; + std::scoped_lock lk{m_guard}; m_is_interrupted = false; - m_arm_interface->ClearInterrupt(); } } // namespace Kernel diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h index 5cb398fdc..bae4fe5b8 100644 --- a/src/core/hle/kernel/physical_core.h +++ b/src/core/hle/kernel/physical_core.h @@ -11,7 +11,7 @@ #include "core/arm/arm_interface.h" namespace Kernel { -class KScheduler; +class KernelCore; } // namespace Kernel namespace Core { @@ -23,62 +23,55 @@ namespace Kernel { class PhysicalCore { public: - PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_); + PhysicalCore(KernelCore& kernel, std::size_t core_index); ~PhysicalCore(); YUZU_NON_COPYABLE(PhysicalCore); YUZU_NON_MOVEABLE(PhysicalCore); - /// Initialize the core for the specified parameters. - void Initialize(bool is_64_bit); + // Execute guest code running on the given thread. + void RunThread(KThread* thread); - /// Execute current jit state - void Run(); + // Copy context from thread to current core. + void LoadContext(const KThread* thread); + void LoadSvcArguments(const KProcess& process, std::span<const uint64_t, 8> args); + // Copy context from current core to thread. + void SaveContext(KThread* thread) const; + void SaveSvcArguments(KProcess& process, std::span<uint64_t, 8> args) const; + + // Copy floating point status registers to the target thread. + void CloneFpuStatus(KThread* dst) const; + + // Log backtrace of current processor state. + void LogBacktrace(); + + // Wait for an interrupt. void Idle(); - /// Interrupt this physical core. + // Interrupt this core. void Interrupt(); - /// Clear this core's interrupt + // Clear this core's interrupt. void ClearInterrupt(); - /// Check if this core is interrupted + // Check if this core is interrupted. bool IsInterrupted() const; - bool IsInitialized() const { - return m_arm_interface != nullptr; - } - - Core::ARM_Interface& ArmInterface() { - return *m_arm_interface; - } - - const Core::ARM_Interface& ArmInterface() const { - return *m_arm_interface; - } - std::size_t CoreIndex() const { return m_core_index; } - Kernel::KScheduler& Scheduler() { - return m_scheduler; - } - - const Kernel::KScheduler& Scheduler() const { - return m_scheduler; - } - private: + KernelCore& m_kernel; const std::size_t m_core_index; - Core::System& m_system; - Kernel::KScheduler& m_scheduler; std::mutex m_guard; std::condition_variable m_on_interrupt; - std::unique_ptr<Core::ARM_Interface> m_arm_interface; + Core::ArmInterface* m_arm_interface{}; + KThread* m_current_thread{}; bool m_is_interrupted{}; + bool m_is_single_core{}; }; } // namespace Kernel diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp index b76683969..c55dc0c8a 100644 --- a/src/core/hle/kernel/svc.cpp +++ b/src/core/hle/kernel/svc.cpp @@ -12,20 +12,20 @@ namespace Kernel::Svc { -static uint32_t GetReg32(Core::System& system, int n) { - return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n)); +static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) { + return static_cast<uint32_t>(args[n]); } -static void SetReg32(Core::System& system, int n, uint32_t result) { - system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result)); +static void SetArg32(std::span<uint64_t, 8> args, int n, uint32_t result) { + args[n] = result; } -static uint64_t GetReg64(Core::System& system, int n) { - return system.CurrentArmInterface().GetReg(n); +static uint64_t GetArg64(std::span<uint64_t, 8> args, int n) { + return args[n]; } -static void SetReg64(Core::System& system, int n, uint64_t result) { - system.CurrentArmInterface().SetReg(n, result); +static void SetArg64(std::span<uint64_t, 8> args, int n, uint64_t result) { + args[n] = result; } // Like bit_cast, but handles the case when the source and dest @@ -79,37 +79,37 @@ static_assert(sizeof(int64_t) == 8); static_assert(sizeof(uint32_t) == 4); static_assert(sizeof(uint64_t) == 8); -static void SvcWrap_SetHeapSize64From32(Core::System& system) { +static void SvcWrap_SetHeapSize64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; uint32_t size{}; - size = Convert<uint32_t>(GetReg32(system, 1)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = SetHeapSize64From32(system, std::addressof(out_address), size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_address)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_address)); } -static void SvcWrap_SetMemoryPermission64From32(Core::System& system) { +static void SvcWrap_SetMemoryPermission64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; MemoryPermission perm{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); - perm = Convert<MemoryPermission>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); + perm = Convert<MemoryPermission>(GetArg32(args, 2)); ret = SetMemoryPermission64From32(system, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) { +static void SvcWrap_SetMemoryAttribute64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -117,69 +117,69 @@ static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) { uint32_t mask{}; uint32_t attr{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); - mask = Convert<uint32_t>(GetReg32(system, 2)); - attr = Convert<uint32_t>(GetReg32(system, 3)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); + mask = Convert<uint32_t>(GetArg32(args, 2)); + attr = Convert<uint32_t>(GetArg32(args, 3)); ret = SetMemoryAttribute64From32(system, address, size, mask, attr); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapMemory64From32(Core::System& system) { +static void SvcWrap_MapMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; uint32_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - src_address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + src_address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = MapMemory64From32(system, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapMemory64From32(Core::System& system) { +static void SvcWrap_UnmapMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; uint32_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - src_address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + src_address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapMemory64From32(system, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_QueryMemory64From32(Core::System& system) { +static void SvcWrap_QueryMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; uint32_t out_memory_info{}; uint32_t address{}; - out_memory_info = Convert<uint32_t>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 2)); + out_memory_info = Convert<uint32_t>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 2)); ret = QueryMemory64From32(system, out_memory_info, std::addressof(out_page_info), address); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_page_info)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_page_info)); } -static void SvcWrap_ExitProcess64From32(Core::System& system) { +static void SvcWrap_ExitProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { ExitProcess64From32(system); } -static void SvcWrap_CreateThread64From32(Core::System& system) { +static void SvcWrap_CreateThread64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -189,143 +189,143 @@ static void SvcWrap_CreateThread64From32(Core::System& system) { int32_t priority{}; int32_t core_id{}; - func = Convert<uint32_t>(GetReg32(system, 1)); - arg = Convert<uint32_t>(GetReg32(system, 2)); - stack_bottom = Convert<uint32_t>(GetReg32(system, 3)); - priority = Convert<int32_t>(GetReg32(system, 0)); - core_id = Convert<int32_t>(GetReg32(system, 4)); + func = Convert<uint32_t>(GetArg32(args, 1)); + arg = Convert<uint32_t>(GetArg32(args, 2)); + stack_bottom = Convert<uint32_t>(GetArg32(args, 3)); + priority = Convert<int32_t>(GetArg32(args, 0)); + core_id = Convert<int32_t>(GetArg32(args, 4)); ret = CreateThread64From32(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_StartThread64From32(Core::System& system) { +static void SvcWrap_StartThread64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); ret = StartThread64From32(system, thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ExitThread64From32(Core::System& system) { +static void SvcWrap_ExitThread64From32(Core::System& system, std::span<uint64_t, 8> args) { ExitThread64From32(system); } -static void SvcWrap_SleepThread64From32(Core::System& system) { +static void SvcWrap_SleepThread64From32(Core::System& system, std::span<uint64_t, 8> args) { int64_t ns{}; std::array<uint32_t, 2> ns_gather{}; - ns_gather[0] = GetReg32(system, 0); - ns_gather[1] = GetReg32(system, 1); + ns_gather[0] = GetArg32(args, 0); + ns_gather[1] = GetArg32(args, 1); ns = Convert<int64_t>(ns_gather); SleepThread64From32(system, ns); } -static void SvcWrap_GetThreadPriority64From32(Core::System& system) { +static void SvcWrap_GetThreadPriority64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_priority{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetThreadPriority64From32(system, std::addressof(out_priority), thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_priority)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_priority)); } -static void SvcWrap_SetThreadPriority64From32(Core::System& system) { +static void SvcWrap_SetThreadPriority64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t priority{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - priority = Convert<int32_t>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + priority = Convert<int32_t>(GetArg32(args, 1)); ret = SetThreadPriority64From32(system, thread_handle, priority); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetThreadCoreMask64From32(Core::System& system) { +static void SvcWrap_GetThreadCoreMask64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_core_id{}; uint64_t out_affinity_mask{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 2)); + thread_handle = Convert<Handle>(GetArg32(args, 2)); ret = GetThreadCoreMask64From32(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_core_id)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_core_id)); auto out_affinity_mask_scatter = Convert<std::array<uint32_t, 2>>(out_affinity_mask); - SetReg32(system, 2, out_affinity_mask_scatter[0]); - SetReg32(system, 3, out_affinity_mask_scatter[1]); + SetArg32(args, 2, out_affinity_mask_scatter[0]); + SetArg32(args, 3, out_affinity_mask_scatter[1]); } -static void SvcWrap_SetThreadCoreMask64From32(Core::System& system) { +static void SvcWrap_SetThreadCoreMask64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t core_id{}; uint64_t affinity_mask{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - core_id = Convert<int32_t>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + core_id = Convert<int32_t>(GetArg32(args, 1)); std::array<uint32_t, 2> affinity_mask_gather{}; - affinity_mask_gather[0] = GetReg32(system, 2); - affinity_mask_gather[1] = GetReg32(system, 3); + affinity_mask_gather[0] = GetArg32(args, 2); + affinity_mask_gather[1] = GetArg32(args, 3); affinity_mask = Convert<uint64_t>(affinity_mask_gather); ret = SetThreadCoreMask64From32(system, thread_handle, core_id, affinity_mask); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system) { +static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system, std::span<uint64_t, 8> args) { int32_t ret{}; ret = GetCurrentProcessorNumber64From32(system); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SignalEvent64From32(Core::System& system) { +static void SvcWrap_SignalEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg32(system, 0)); + event_handle = Convert<Handle>(GetArg32(args, 0)); ret = SignalEvent64From32(system, event_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ClearEvent64From32(Core::System& system) { +static void SvcWrap_ClearEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg32(system, 0)); + event_handle = Convert<Handle>(GetArg32(args, 0)); ret = ClearEvent64From32(system, event_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapSharedMemory64From32(Core::System& system) { +static void SvcWrap_MapSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; @@ -333,33 +333,33 @@ static void SvcWrap_MapSharedMemory64From32(Core::System& system) { uint32_t size{}; MemoryPermission map_perm{}; - shmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + shmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = MapSharedMemory64From32(system, shmem_handle, address, size, map_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapSharedMemory64From32(Core::System& system) { +static void SvcWrap_UnmapSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; uint32_t address{}; uint32_t size{}; - shmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + shmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapSharedMemory64From32(system, shmem_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateTransferMemory64From32(Core::System& system) { +static void SvcWrap_CreateTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -367,41 +367,41 @@ static void SvcWrap_CreateTransferMemory64From32(Core::System& system) { uint32_t size{}; MemoryPermission map_perm{}; - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = CreateTransferMemory64From32(system, std::addressof(out_handle), address, size, map_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_CloseHandle64From32(Core::System& system) { +static void SvcWrap_CloseHandle64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg32(system, 0)); + handle = Convert<Handle>(GetArg32(args, 0)); ret = CloseHandle64From32(system, handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ResetSignal64From32(Core::System& system) { +static void SvcWrap_ResetSignal64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg32(system, 0)); + handle = Convert<Handle>(GetArg32(args, 0)); ret = ResetSignal64From32(system, handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WaitSynchronization64From32(Core::System& system) { +static void SvcWrap_WaitSynchronization64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -409,60 +409,60 @@ static void SvcWrap_WaitSynchronization64From32(Core::System& system) { int32_t num_handles{}; int64_t timeout_ns{}; - handles = Convert<uint32_t>(GetReg32(system, 1)); - num_handles = Convert<int32_t>(GetReg32(system, 2)); + handles = Convert<uint32_t>(GetArg32(args, 1)); + num_handles = Convert<int32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 0); - timeout_ns_gather[1] = GetReg32(system, 3); + timeout_ns_gather[0] = GetArg32(args, 0); + timeout_ns_gather[1] = GetArg32(args, 3); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = WaitSynchronization64From32(system, std::addressof(out_index), handles, num_handles, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_index)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_index)); } -static void SvcWrap_CancelSynchronization64From32(Core::System& system) { +static void SvcWrap_CancelSynchronization64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg32(system, 0)); + handle = Convert<Handle>(GetArg32(args, 0)); ret = CancelSynchronization64From32(system, handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ArbitrateLock64From32(Core::System& system) { +static void SvcWrap_ArbitrateLock64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; uint32_t address{}; uint32_t tag{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - tag = Convert<uint32_t>(GetReg32(system, 2)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + tag = Convert<uint32_t>(GetArg32(args, 2)); ret = ArbitrateLock64From32(system, thread_handle, address, tag); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ArbitrateUnlock64From32(Core::System& system) { +static void SvcWrap_ArbitrateUnlock64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; - address = Convert<uint32_t>(GetReg32(system, 0)); + address = Convert<uint32_t>(GetArg32(args, 0)); ret = ArbitrateUnlock64From32(system, address); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) { +static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -470,82 +470,82 @@ static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) { uint32_t tag{}; int64_t timeout_ns{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - cv_key = Convert<uint32_t>(GetReg32(system, 1)); - tag = Convert<uint32_t>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 0)); + cv_key = Convert<uint32_t>(GetArg32(args, 1)); + tag = Convert<uint32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 3); - timeout_ns_gather[1] = GetReg32(system, 4); + timeout_ns_gather[0] = GetArg32(args, 3); + timeout_ns_gather[1] = GetArg32(args, 4); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = WaitProcessWideKeyAtomic64From32(system, address, cv_key, tag, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SignalProcessWideKey64From32(Core::System& system) { +static void SvcWrap_SignalProcessWideKey64From32(Core::System& system, std::span<uint64_t, 8> args) { uint32_t cv_key{}; int32_t count{}; - cv_key = Convert<uint32_t>(GetReg32(system, 0)); - count = Convert<int32_t>(GetReg32(system, 1)); + cv_key = Convert<uint32_t>(GetArg32(args, 0)); + count = Convert<int32_t>(GetArg32(args, 1)); SignalProcessWideKey64From32(system, cv_key, count); } -static void SvcWrap_GetSystemTick64From32(Core::System& system) { +static void SvcWrap_GetSystemTick64From32(Core::System& system, std::span<uint64_t, 8> args) { int64_t ret{}; ret = GetSystemTick64From32(system); auto ret_scatter = Convert<std::array<uint32_t, 2>>(ret); - SetReg32(system, 0, ret_scatter[0]); - SetReg32(system, 1, ret_scatter[1]); + SetArg32(args, 0, ret_scatter[0]); + SetArg32(args, 1, ret_scatter[1]); } -static void SvcWrap_ConnectToNamedPort64From32(Core::System& system) { +static void SvcWrap_ConnectToNamedPort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint32_t name{}; - name = Convert<uint32_t>(GetReg32(system, 1)); + name = Convert<uint32_t>(GetArg32(args, 1)); ret = ConnectToNamedPort64From32(system, std::addressof(out_handle), name); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_SendSyncRequest64From32(Core::System& system) { +static void SvcWrap_SendSyncRequest64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle session_handle{}; - session_handle = Convert<Handle>(GetReg32(system, 0)); + session_handle = Convert<Handle>(GetArg32(args, 0)); ret = SendSyncRequest64From32(system, session_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system) { +static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t message_buffer{}; uint32_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint32_t>(GetReg32(system, 0)); - message_buffer_size = Convert<uint32_t>(GetReg32(system, 1)); - session_handle = Convert<Handle>(GetReg32(system, 2)); + message_buffer = Convert<uint32_t>(GetArg32(args, 0)); + message_buffer_size = Convert<uint32_t>(GetArg32(args, 1)); + session_handle = Convert<Handle>(GetArg32(args, 2)); ret = SendSyncRequestWithUserBuffer64From32(system, message_buffer, message_buffer_size, session_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system) { +static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_event_handle{}; @@ -553,83 +553,83 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system) uint32_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint32_t>(GetReg32(system, 1)); - message_buffer_size = Convert<uint32_t>(GetReg32(system, 2)); - session_handle = Convert<Handle>(GetReg32(system, 3)); + message_buffer = Convert<uint32_t>(GetArg32(args, 1)); + message_buffer_size = Convert<uint32_t>(GetArg32(args, 2)); + session_handle = Convert<Handle>(GetArg32(args, 3)); ret = SendAsyncRequestWithUserBuffer64From32(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_event_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_event_handle)); } -static void SvcWrap_GetProcessId64From32(Core::System& system) { +static void SvcWrap_GetProcessId64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_process_id{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg32(system, 1)); + process_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetProcessId64From32(system, std::addressof(out_process_id), process_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_process_id_scatter = Convert<std::array<uint32_t, 2>>(out_process_id); - SetReg32(system, 1, out_process_id_scatter[0]); - SetReg32(system, 2, out_process_id_scatter[1]); + SetArg32(args, 1, out_process_id_scatter[0]); + SetArg32(args, 2, out_process_id_scatter[1]); } -static void SvcWrap_GetThreadId64From32(Core::System& system) { +static void SvcWrap_GetThreadId64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_thread_id{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetThreadId64From32(system, std::addressof(out_thread_id), thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id); - SetReg32(system, 1, out_thread_id_scatter[0]); - SetReg32(system, 2, out_thread_id_scatter[1]); + SetArg32(args, 1, out_thread_id_scatter[0]); + SetArg32(args, 2, out_thread_id_scatter[1]); } -static void SvcWrap_Break64From32(Core::System& system) { +static void SvcWrap_Break64From32(Core::System& system, std::span<uint64_t, 8> args) { BreakReason break_reason{}; uint32_t arg{}; uint32_t size{}; - break_reason = Convert<BreakReason>(GetReg32(system, 0)); - arg = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + break_reason = Convert<BreakReason>(GetArg32(args, 0)); + arg = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); Break64From32(system, break_reason, arg, size); } -static void SvcWrap_OutputDebugString64From32(Core::System& system) { +static void SvcWrap_OutputDebugString64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t debug_str{}; uint32_t len{}; - debug_str = Convert<uint32_t>(GetReg32(system, 0)); - len = Convert<uint32_t>(GetReg32(system, 1)); + debug_str = Convert<uint32_t>(GetArg32(args, 0)); + len = Convert<uint32_t>(GetArg32(args, 1)); ret = OutputDebugString64From32(system, debug_str, len); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ReturnFromException64From32(Core::System& system) { +static void SvcWrap_ReturnFromException64From32(Core::System& system, std::span<uint64_t, 8> args) { Result result{}; - result = Convert<Result>(GetReg32(system, 0)); + result = Convert<Result>(GetArg32(args, 0)); ReturnFromException64From32(system, result); } -static void SvcWrap_GetInfo64From32(Core::System& system) { +static void SvcWrap_GetInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -637,68 +637,68 @@ static void SvcWrap_GetInfo64From32(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<InfoType>(GetReg32(system, 1)); - handle = Convert<Handle>(GetReg32(system, 2)); + info_type = Convert<InfoType>(GetArg32(args, 1)); + handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> info_subtype_gather{}; - info_subtype_gather[0] = GetReg32(system, 0); - info_subtype_gather[1] = GetReg32(system, 3); + info_subtype_gather[0] = GetArg32(args, 0); + info_subtype_gather[1] = GetArg32(args, 3); info_subtype = Convert<uint64_t>(info_subtype_gather); ret = GetInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_scatter = Convert<std::array<uint32_t, 2>>(out); - SetReg32(system, 1, out_scatter[0]); - SetReg32(system, 2, out_scatter[1]); + SetArg32(args, 1, out_scatter[0]); + SetArg32(args, 2, out_scatter[1]); } -static void SvcWrap_FlushEntireDataCache64From32(Core::System& system) { +static void SvcWrap_FlushEntireDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { FlushEntireDataCache64From32(system); } -static void SvcWrap_FlushDataCache64From32(Core::System& system) { +static void SvcWrap_FlushDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = FlushDataCache64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapPhysicalMemory64From32(Core::System& system) { +static void SvcWrap_MapPhysicalMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = MapPhysicalMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = UnmapPhysicalMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) { +static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; ilp32::LastThreadContext out_context{}; @@ -706,26 +706,26 @@ static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) { Handle debug_handle{}; int64_t ns{}; - debug_handle = Convert<Handle>(GetReg32(system, 2)); + debug_handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> ns_gather{}; - ns_gather[0] = GetReg32(system, 0); - ns_gather[1] = GetReg32(system, 1); + ns_gather[0] = GetArg32(args, 0); + ns_gather[1] = GetArg32(args, 1); ns = Convert<int64_t>(ns_gather); ret = GetDebugFutureThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context); - SetReg32(system, 1, out_context_scatter[0]); - SetReg32(system, 2, out_context_scatter[1]); - SetReg32(system, 3, out_context_scatter[2]); - SetReg32(system, 4, out_context_scatter[3]); + SetArg32(args, 1, out_context_scatter[0]); + SetArg32(args, 2, out_context_scatter[1]); + SetArg32(args, 3, out_context_scatter[2]); + SetArg32(args, 4, out_context_scatter[3]); auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id); - SetReg32(system, 5, out_thread_id_scatter[0]); - SetReg32(system, 6, out_thread_id_scatter[1]); + SetArg32(args, 5, out_thread_id_scatter[0]); + SetArg32(args, 6, out_thread_id_scatter[1]); } -static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) { +static void SvcWrap_GetLastThreadInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; ilp32::LastThreadContext out_context{}; @@ -734,81 +734,81 @@ static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) { ret = GetLastThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context); - SetReg32(system, 1, out_context_scatter[0]); - SetReg32(system, 2, out_context_scatter[1]); - SetReg32(system, 3, out_context_scatter[2]); - SetReg32(system, 4, out_context_scatter[3]); - SetReg32(system, 5, Convert<uint32_t>(out_tls_address)); - SetReg32(system, 6, Convert<uint32_t>(out_flags)); + SetArg32(args, 1, out_context_scatter[0]); + SetArg32(args, 2, out_context_scatter[1]); + SetArg32(args, 3, out_context_scatter[2]); + SetArg32(args, 4, out_context_scatter[3]); + SetArg32(args, 5, Convert<uint32_t>(out_tls_address)); + SetArg32(args, 6, Convert<uint32_t>(out_flags)); } -static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system) { +static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_limit_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); - which = Convert<LimitableResource>(GetReg32(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 1)); + which = Convert<LimitableResource>(GetArg32(args, 2)); ret = GetResourceLimitLimitValue64From32(system, std::addressof(out_limit_value), resource_limit_handle, which); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_limit_value_scatter = Convert<std::array<uint32_t, 2>>(out_limit_value); - SetReg32(system, 1, out_limit_value_scatter[0]); - SetReg32(system, 2, out_limit_value_scatter[1]); + SetArg32(args, 1, out_limit_value_scatter[0]); + SetArg32(args, 2, out_limit_value_scatter[1]); } -static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system) { +static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_current_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); - which = Convert<LimitableResource>(GetReg32(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 1)); + which = Convert<LimitableResource>(GetArg32(args, 2)); ret = GetResourceLimitCurrentValue64From32(system, std::addressof(out_current_value), resource_limit_handle, which); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_current_value_scatter = Convert<std::array<uint32_t, 2>>(out_current_value); - SetReg32(system, 1, out_current_value_scatter[0]); - SetReg32(system, 2, out_current_value_scatter[1]); + SetArg32(args, 1, out_current_value_scatter[0]); + SetArg32(args, 2, out_current_value_scatter[1]); } -static void SvcWrap_SetThreadActivity64From32(Core::System& system) { +static void SvcWrap_SetThreadActivity64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; ThreadActivity thread_activity{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - thread_activity = Convert<ThreadActivity>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + thread_activity = Convert<ThreadActivity>(GetArg32(args, 1)); ret = SetThreadActivity64From32(system, thread_handle, thread_activity); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetThreadContext364From32(Core::System& system) { +static void SvcWrap_GetThreadContext364From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_context{}; Handle thread_handle{}; - out_context = Convert<uint32_t>(GetReg32(system, 0)); - thread_handle = Convert<Handle>(GetReg32(system, 1)); + out_context = Convert<uint32_t>(GetArg32(args, 0)); + thread_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetThreadContext364From32(system, out_context, thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WaitForAddress64From32(Core::System& system) { +static void SvcWrap_WaitForAddress64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -816,20 +816,20 @@ static void SvcWrap_WaitForAddress64From32(Core::System& system) { int32_t value{}; int64_t timeout_ns{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - arb_type = Convert<ArbitrationType>(GetReg32(system, 1)); - value = Convert<int32_t>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 0)); + arb_type = Convert<ArbitrationType>(GetArg32(args, 1)); + value = Convert<int32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 3); - timeout_ns_gather[1] = GetReg32(system, 4); + timeout_ns_gather[0] = GetArg32(args, 3); + timeout_ns_gather[1] = GetArg32(args, 4); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = WaitForAddress64From32(system, address, arb_type, value, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SignalToAddress64From32(Core::System& system) { +static void SvcWrap_SignalToAddress64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -837,53 +837,53 @@ static void SvcWrap_SignalToAddress64From32(Core::System& system) { int32_t value{}; int32_t count{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - signal_type = Convert<SignalType>(GetReg32(system, 1)); - value = Convert<int32_t>(GetReg32(system, 2)); - count = Convert<int32_t>(GetReg32(system, 3)); + address = Convert<uint32_t>(GetArg32(args, 0)); + signal_type = Convert<SignalType>(GetArg32(args, 1)); + value = Convert<int32_t>(GetArg32(args, 2)); + count = Convert<int32_t>(GetArg32(args, 3)); ret = SignalToAddress64From32(system, address, signal_type, value, count); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system) { +static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system, std::span<uint64_t, 8> args) { SynchronizePreemptionState64From32(system); } -static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system) { +static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_peak_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); - which = Convert<LimitableResource>(GetReg32(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 1)); + which = Convert<LimitableResource>(GetArg32(args, 2)); ret = GetResourceLimitPeakValue64From32(system, std::addressof(out_peak_value), resource_limit_handle, which); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_peak_value_scatter = Convert<std::array<uint32_t, 2>>(out_peak_value); - SetReg32(system, 1, out_peak_value_scatter[0]); - SetReg32(system, 2, out_peak_value_scatter[1]); + SetArg32(args, 1, out_peak_value_scatter[0]); + SetArg32(args, 2, out_peak_value_scatter[1]); } -static void SvcWrap_CreateIoPool64From32(Core::System& system) { +static void SvcWrap_CreateIoPool64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; IoPoolType which{}; - which = Convert<IoPoolType>(GetReg32(system, 1)); + which = Convert<IoPoolType>(GetArg32(args, 1)); ret = CreateIoPool64From32(system, std::addressof(out_handle), which); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_CreateIoRegion64From32(Core::System& system) { +static void SvcWrap_CreateIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -893,53 +893,53 @@ static void SvcWrap_CreateIoRegion64From32(Core::System& system) { MemoryMapping mapping{}; MemoryPermission perm{}; - io_pool = Convert<Handle>(GetReg32(system, 1)); + io_pool = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> physical_address_gather{}; - physical_address_gather[0] = GetReg32(system, 2); - physical_address_gather[1] = GetReg32(system, 3); + physical_address_gather[0] = GetArg32(args, 2); + physical_address_gather[1] = GetArg32(args, 3); physical_address = Convert<uint64_t>(physical_address_gather); - size = Convert<uint32_t>(GetReg32(system, 0)); - mapping = Convert<MemoryMapping>(GetReg32(system, 4)); - perm = Convert<MemoryPermission>(GetReg32(system, 5)); + size = Convert<uint32_t>(GetArg32(args, 0)); + mapping = Convert<MemoryMapping>(GetArg32(args, 4)); + perm = Convert<MemoryPermission>(GetArg32(args, 5)); ret = CreateIoRegion64From32(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_KernelDebug64From32(Core::System& system) { +static void SvcWrap_KernelDebug64From32(Core::System& system, std::span<uint64_t, 8> args) { KernelDebugType kern_debug_type{}; uint64_t arg0{}; uint64_t arg1{}; uint64_t arg2{}; - kern_debug_type = Convert<KernelDebugType>(GetReg32(system, 0)); + kern_debug_type = Convert<KernelDebugType>(GetArg32(args, 0)); std::array<uint32_t, 2> arg0_gather{}; - arg0_gather[0] = GetReg32(system, 2); - arg0_gather[1] = GetReg32(system, 3); + arg0_gather[0] = GetArg32(args, 2); + arg0_gather[1] = GetArg32(args, 3); arg0 = Convert<uint64_t>(arg0_gather); std::array<uint32_t, 2> arg1_gather{}; - arg1_gather[0] = GetReg32(system, 1); - arg1_gather[1] = GetReg32(system, 4); + arg1_gather[0] = GetArg32(args, 1); + arg1_gather[1] = GetArg32(args, 4); arg1 = Convert<uint64_t>(arg1_gather); std::array<uint32_t, 2> arg2_gather{}; - arg2_gather[0] = GetReg32(system, 5); - arg2_gather[1] = GetReg32(system, 6); + arg2_gather[0] = GetArg32(args, 5); + arg2_gather[1] = GetArg32(args, 6); arg2 = Convert<uint64_t>(arg2_gather); KernelDebug64From32(system, kern_debug_type, arg0, arg1, arg2); } -static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system) { +static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system, std::span<uint64_t, 8> args) { KernelTraceState kern_trace_state{}; - kern_trace_state = Convert<KernelTraceState>(GetReg32(system, 0)); + kern_trace_state = Convert<KernelTraceState>(GetArg32(args, 0)); ChangeKernelTraceState64From32(system, kern_trace_state); } -static void SvcWrap_CreateSession64From32(Core::System& system) { +static void SvcWrap_CreateSession64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_session_handle{}; @@ -947,31 +947,31 @@ static void SvcWrap_CreateSession64From32(Core::System& system) { bool is_light{}; uint32_t name{}; - is_light = Convert<bool>(GetReg32(system, 2)); - name = Convert<uint32_t>(GetReg32(system, 3)); + is_light = Convert<bool>(GetArg32(args, 2)); + name = Convert<uint32_t>(GetArg32(args, 3)); ret = CreateSession64From32(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_server_session_handle)); - SetReg32(system, 2, Convert<uint32_t>(out_client_session_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_server_session_handle)); + SetArg32(args, 2, Convert<uint32_t>(out_client_session_handle)); } -static void SvcWrap_AcceptSession64From32(Core::System& system) { +static void SvcWrap_AcceptSession64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg32(system, 1)); + port = Convert<Handle>(GetArg32(args, 1)); ret = AcceptSession64From32(system, std::addressof(out_handle), port); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_ReplyAndReceive64From32(Core::System& system) { +static void SvcWrap_ReplyAndReceive64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -980,21 +980,21 @@ static void SvcWrap_ReplyAndReceive64From32(Core::System& system) { Handle reply_target{}; int64_t timeout_ns{}; - handles = Convert<uint32_t>(GetReg32(system, 1)); - num_handles = Convert<int32_t>(GetReg32(system, 2)); - reply_target = Convert<Handle>(GetReg32(system, 3)); + handles = Convert<uint32_t>(GetArg32(args, 1)); + num_handles = Convert<int32_t>(GetArg32(args, 2)); + reply_target = Convert<Handle>(GetArg32(args, 3)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 0); - timeout_ns_gather[1] = GetReg32(system, 4); + timeout_ns_gather[0] = GetArg32(args, 0); + timeout_ns_gather[1] = GetArg32(args, 4); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = ReplyAndReceive64From32(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_index)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_index)); } -static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system) { +static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -1005,23 +1005,23 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system) Handle reply_target{}; int64_t timeout_ns{}; - message_buffer = Convert<uint32_t>(GetReg32(system, 1)); - message_buffer_size = Convert<uint32_t>(GetReg32(system, 2)); - handles = Convert<uint32_t>(GetReg32(system, 3)); - num_handles = Convert<int32_t>(GetReg32(system, 0)); - reply_target = Convert<Handle>(GetReg32(system, 4)); + message_buffer = Convert<uint32_t>(GetArg32(args, 1)); + message_buffer_size = Convert<uint32_t>(GetArg32(args, 2)); + handles = Convert<uint32_t>(GetArg32(args, 3)); + num_handles = Convert<int32_t>(GetArg32(args, 0)); + reply_target = Convert<Handle>(GetArg32(args, 4)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 5); - timeout_ns_gather[1] = GetReg32(system, 6); + timeout_ns_gather[0] = GetArg32(args, 5); + timeout_ns_gather[1] = GetArg32(args, 6); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = ReplyAndReceiveWithUserBuffer64From32(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_index)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_index)); } -static void SvcWrap_CreateEvent64From32(Core::System& system) { +static void SvcWrap_CreateEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_write_handle{}; @@ -1029,12 +1029,12 @@ static void SvcWrap_CreateEvent64From32(Core::System& system) { ret = CreateEvent64From32(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_write_handle)); - SetReg32(system, 2, Convert<uint32_t>(out_read_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_write_handle)); + SetArg32(args, 2, Convert<uint32_t>(out_read_handle)); } -static void SvcWrap_MapIoRegion64From32(Core::System& system) { +static void SvcWrap_MapIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; @@ -1042,89 +1042,89 @@ static void SvcWrap_MapIoRegion64From32(Core::System& system) { uint32_t size{}; MemoryPermission perm{}; - io_region = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - perm = Convert<MemoryPermission>(GetReg32(system, 3)); + io_region = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = MapIoRegion64From32(system, io_region, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapIoRegion64From32(Core::System& system) { +static void SvcWrap_UnmapIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; uint32_t address{}; uint32_t size{}; - io_region = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + io_region = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapIoRegion64From32(system, io_region, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system) { +static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = MapPhysicalMemoryUnsafe64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = UnmapPhysicalMemoryUnsafe64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetUnsafeLimit64From32(Core::System& system) { +static void SvcWrap_SetUnsafeLimit64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t limit{}; - limit = Convert<uint32_t>(GetReg32(system, 0)); + limit = Convert<uint32_t>(GetArg32(args, 0)); ret = SetUnsafeLimit64From32(system, limit); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateCodeMemory64From32(Core::System& system) { +static void SvcWrap_CreateCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = CreateCodeMemory64From32(system, std::addressof(out_handle), address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_ControlCodeMemory64From32(Core::System& system) { +static void SvcWrap_ControlCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle code_memory_handle{}; @@ -1133,28 +1133,28 @@ static void SvcWrap_ControlCodeMemory64From32(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - code_memory_handle = Convert<Handle>(GetReg32(system, 0)); - operation = Convert<CodeMemoryOperation>(GetReg32(system, 1)); + code_memory_handle = Convert<Handle>(GetArg32(args, 0)); + operation = Convert<CodeMemoryOperation>(GetArg32(args, 1)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 4); - size_gather[1] = GetReg32(system, 5); + size_gather[0] = GetArg32(args, 4); + size_gather[1] = GetArg32(args, 5); size = Convert<uint64_t>(size_gather); - perm = Convert<MemoryPermission>(GetReg32(system, 6)); + perm = Convert<MemoryPermission>(GetArg32(args, 6)); ret = ControlCodeMemory64From32(system, code_memory_handle, operation, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SleepSystem64From32(Core::System& system) { +static void SvcWrap_SleepSystem64From32(Core::System& system, std::span<uint64_t, 8> args) { SleepSystem64From32(system); } -static void SvcWrap_ReadWriteRegister64From32(Core::System& system) { +static void SvcWrap_ReadWriteRegister64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_value{}; @@ -1163,33 +1163,33 @@ static void SvcWrap_ReadWriteRegister64From32(Core::System& system) { uint32_t value{}; std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); - mask = Convert<uint32_t>(GetReg32(system, 0)); - value = Convert<uint32_t>(GetReg32(system, 1)); + mask = Convert<uint32_t>(GetArg32(args, 0)); + value = Convert<uint32_t>(GetArg32(args, 1)); ret = ReadWriteRegister64From32(system, std::addressof(out_value), address, mask, value); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_value)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_value)); } -static void SvcWrap_SetProcessActivity64From32(Core::System& system) { +static void SvcWrap_SetProcessActivity64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; ProcessActivity process_activity{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); - process_activity = Convert<ProcessActivity>(GetReg32(system, 1)); + process_handle = Convert<Handle>(GetArg32(args, 0)); + process_activity = Convert<ProcessActivity>(GetArg32(args, 1)); ret = SetProcessActivity64From32(system, process_handle, process_activity); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateSharedMemory64From32(Core::System& system) { +static void SvcWrap_CreateSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -1197,17 +1197,17 @@ static void SvcWrap_CreateSharedMemory64From32(Core::System& system) { MemoryPermission owner_perm{}; MemoryPermission remote_perm{}; - size = Convert<uint32_t>(GetReg32(system, 1)); - owner_perm = Convert<MemoryPermission>(GetReg32(system, 2)); - remote_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + size = Convert<uint32_t>(GetArg32(args, 1)); + owner_perm = Convert<MemoryPermission>(GetArg32(args, 2)); + remote_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = CreateSharedMemory64From32(system, std::addressof(out_handle), size, owner_perm, remote_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_MapTransferMemory64From32(Core::System& system) { +static void SvcWrap_MapTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; @@ -1215,67 +1215,67 @@ static void SvcWrap_MapTransferMemory64From32(Core::System& system) { uint32_t size{}; MemoryPermission owner_perm{}; - trmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - owner_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + trmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + owner_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = MapTransferMemory64From32(system, trmem_handle, address, size, owner_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapTransferMemory64From32(Core::System& system) { +static void SvcWrap_UnmapTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; uint32_t address{}; uint32_t size{}; - trmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + trmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapTransferMemory64From32(system, trmem_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateInterruptEvent64From32(Core::System& system) { +static void SvcWrap_CreateInterruptEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_read_handle{}; int32_t interrupt_id{}; InterruptType interrupt_type{}; - interrupt_id = Convert<int32_t>(GetReg32(system, 1)); - interrupt_type = Convert<InterruptType>(GetReg32(system, 2)); + interrupt_id = Convert<int32_t>(GetArg32(args, 1)); + interrupt_type = Convert<InterruptType>(GetArg32(args, 2)); ret = CreateInterruptEvent64From32(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_read_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_read_handle)); } -static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system) { +static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; ilp32::PhysicalMemoryInfo out_info{}; uint32_t address{}; - address = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 1)); ret = QueryPhysicalAddress64From32(system, std::addressof(out_info), address); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_info_scatter = Convert<std::array<uint32_t, 4>>(out_info); - SetReg32(system, 1, out_info_scatter[0]); - SetReg32(system, 2, out_info_scatter[1]); - SetReg32(system, 3, out_info_scatter[2]); - SetReg32(system, 4, out_info_scatter[3]); + SetArg32(args, 1, out_info_scatter[0]); + SetArg32(args, 2, out_info_scatter[1]); + SetArg32(args, 3, out_info_scatter[2]); + SetArg32(args, 4, out_info_scatter[3]); } -static void SvcWrap_QueryIoMapping64From32(Core::System& system) { +static void SvcWrap_QueryIoMapping64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; @@ -1284,19 +1284,19 @@ static void SvcWrap_QueryIoMapping64From32(Core::System& system) { uint32_t size{}; std::array<uint32_t, 2> physical_address_gather{}; - physical_address_gather[0] = GetReg32(system, 2); - physical_address_gather[1] = GetReg32(system, 3); + physical_address_gather[0] = GetArg32(args, 2); + physical_address_gather[1] = GetArg32(args, 3); physical_address = Convert<uint64_t>(physical_address_gather); - size = Convert<uint32_t>(GetReg32(system, 0)); + size = Convert<uint32_t>(GetArg32(args, 0)); ret = QueryIoMapping64From32(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_address)); - SetReg32(system, 2, Convert<uint32_t>(out_size)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_address)); + SetArg32(args, 2, Convert<uint32_t>(out_size)); } -static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -1304,49 +1304,49 @@ static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) { uint64_t das_size{}; std::array<uint32_t, 2> das_address_gather{}; - das_address_gather[0] = GetReg32(system, 2); - das_address_gather[1] = GetReg32(system, 3); + das_address_gather[0] = GetArg32(args, 2); + das_address_gather[1] = GetArg32(args, 3); das_address = Convert<uint64_t>(das_address_gather); std::array<uint32_t, 2> das_size_gather{}; - das_size_gather[0] = GetReg32(system, 0); - das_size_gather[1] = GetReg32(system, 1); + das_size_gather[0] = GetArg32(args, 0); + das_size_gather[1] = GetArg32(args, 1); das_size = Convert<uint64_t>(das_size_gather); ret = CreateDeviceAddressSpace64From32(system, std::addressof(out_handle), das_address, das_size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg32(system, 0)); - das_handle = Convert<Handle>(GetReg32(system, 1)); + device_name = Convert<DeviceName>(GetArg32(args, 0)); + das_handle = Convert<Handle>(GetArg32(args, 1)); ret = AttachDeviceAddressSpace64From32(system, device_name, das_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg32(system, 0)); - das_handle = Convert<Handle>(GetReg32(system, 1)); + device_name = Convert<DeviceName>(GetArg32(args, 0)); + das_handle = Convert<Handle>(GetArg32(args, 1)); ret = DetachDeviceAddressSpace64From32(system, device_name, das_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -1356,25 +1356,25 @@ static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + das_handle = Convert<Handle>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> process_address_gather{}; - process_address_gather[0] = GetReg32(system, 2); - process_address_gather[1] = GetReg32(system, 3); + process_address_gather[0] = GetArg32(args, 2); + process_address_gather[1] = GetArg32(args, 3); process_address = Convert<uint64_t>(process_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); std::array<uint32_t, 2> device_address_gather{}; - device_address_gather[0] = GetReg32(system, 5); - device_address_gather[1] = GetReg32(system, 6); + device_address_gather[0] = GetArg32(args, 5); + device_address_gather[1] = GetArg32(args, 6); device_address = Convert<uint64_t>(device_address_gather); - option = Convert<uint32_t>(GetReg32(system, 7)); + option = Convert<uint32_t>(GetArg32(args, 7)); ret = MapDeviceAddressSpaceByForce64From32(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -1384,25 +1384,25 @@ static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + das_handle = Convert<Handle>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> process_address_gather{}; - process_address_gather[0] = GetReg32(system, 2); - process_address_gather[1] = GetReg32(system, 3); + process_address_gather[0] = GetArg32(args, 2); + process_address_gather[1] = GetArg32(args, 3); process_address = Convert<uint64_t>(process_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); std::array<uint32_t, 2> device_address_gather{}; - device_address_gather[0] = GetReg32(system, 5); - device_address_gather[1] = GetReg32(system, 6); + device_address_gather[0] = GetArg32(args, 5); + device_address_gather[1] = GetArg32(args, 6); device_address = Convert<uint64_t>(device_address_gather); - option = Convert<uint32_t>(GetReg32(system, 7)); + option = Convert<uint32_t>(GetArg32(args, 7)); ret = MapDeviceAddressSpaceAligned64From32(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -1411,145 +1411,145 @@ static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) { uint32_t size{}; uint64_t device_address{}; - das_handle = Convert<Handle>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + das_handle = Convert<Handle>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> process_address_gather{}; - process_address_gather[0] = GetReg32(system, 2); - process_address_gather[1] = GetReg32(system, 3); + process_address_gather[0] = GetArg32(args, 2); + process_address_gather[1] = GetArg32(args, 3); process_address = Convert<uint64_t>(process_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); std::array<uint32_t, 2> device_address_gather{}; - device_address_gather[0] = GetReg32(system, 5); - device_address_gather[1] = GetReg32(system, 6); + device_address_gather[0] = GetArg32(args, 5); + device_address_gather[1] = GetArg32(args, 6); device_address = Convert<uint64_t>(device_address_gather); ret = UnmapDeviceAddressSpace64From32(system, das_handle, process_handle, process_address, size, device_address); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system) { +static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); ret = InvalidateProcessDataCache64From32(system, process_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_StoreProcessDataCache64From32(Core::System& system) { +static void SvcWrap_StoreProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); ret = StoreProcessDataCache64From32(system, process_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_FlushProcessDataCache64From32(Core::System& system) { +static void SvcWrap_FlushProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); ret = FlushProcessDataCache64From32(system, process_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_DebugActiveProcess64From32(Core::System& system) { +static void SvcWrap_DebugActiveProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t process_id{}; std::array<uint32_t, 2> process_id_gather{}; - process_id_gather[0] = GetReg32(system, 2); - process_id_gather[1] = GetReg32(system, 3); + process_id_gather[0] = GetArg32(args, 2); + process_id_gather[1] = GetArg32(args, 3); process_id = Convert<uint64_t>(process_id_gather); ret = DebugActiveProcess64From32(system, std::addressof(out_handle), process_id); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_BreakDebugProcess64From32(Core::System& system) { +static void SvcWrap_BreakDebugProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); ret = BreakDebugProcess64From32(system, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_TerminateDebugProcess64From32(Core::System& system) { +static void SvcWrap_TerminateDebugProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); ret = TerminateDebugProcess64From32(system, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetDebugEvent64From32(Core::System& system) { +static void SvcWrap_GetDebugEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_info{}; Handle debug_handle{}; - out_info = Convert<uint32_t>(GetReg32(system, 0)); - debug_handle = Convert<Handle>(GetReg32(system, 1)); + out_info = Convert<uint32_t>(GetArg32(args, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetDebugEvent64From32(system, out_info, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) { +static void SvcWrap_ContinueDebugEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -1557,33 +1557,33 @@ static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) { uint32_t thread_ids{}; int32_t num_thread_ids{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); - flags = Convert<uint32_t>(GetReg32(system, 1)); - thread_ids = Convert<uint32_t>(GetReg32(system, 2)); - num_thread_ids = Convert<int32_t>(GetReg32(system, 3)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); + flags = Convert<uint32_t>(GetArg32(args, 1)); + thread_ids = Convert<uint32_t>(GetArg32(args, 2)); + num_thread_ids = Convert<int32_t>(GetArg32(args, 3)); ret = ContinueDebugEvent64From32(system, debug_handle, flags, thread_ids, num_thread_ids); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetProcessList64From32(Core::System& system) { +static void SvcWrap_GetProcessList64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_processes{}; uint32_t out_process_ids{}; int32_t max_out_count{}; - out_process_ids = Convert<uint32_t>(GetReg32(system, 1)); - max_out_count = Convert<int32_t>(GetReg32(system, 2)); + out_process_ids = Convert<uint32_t>(GetArg32(args, 1)); + max_out_count = Convert<int32_t>(GetArg32(args, 2)); ret = GetProcessList64From32(system, std::addressof(out_num_processes), out_process_ids, max_out_count); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_num_processes)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_num_processes)); } -static void SvcWrap_GetThreadList64From32(Core::System& system) { +static void SvcWrap_GetThreadList64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_threads{}; @@ -1591,17 +1591,17 @@ static void SvcWrap_GetThreadList64From32(Core::System& system) { int32_t max_out_count{}; Handle debug_handle{}; - out_thread_ids = Convert<uint32_t>(GetReg32(system, 1)); - max_out_count = Convert<int32_t>(GetReg32(system, 2)); - debug_handle = Convert<Handle>(GetReg32(system, 3)); + out_thread_ids = Convert<uint32_t>(GetArg32(args, 1)); + max_out_count = Convert<int32_t>(GetArg32(args, 2)); + debug_handle = Convert<Handle>(GetArg32(args, 3)); ret = GetThreadList64From32(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_num_threads)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_num_threads)); } -static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) { +static void SvcWrap_GetDebugThreadContext64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_context{}; @@ -1609,20 +1609,20 @@ static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) { uint64_t thread_id{}; uint32_t context_flags{}; - out_context = Convert<uint32_t>(GetReg32(system, 0)); - debug_handle = Convert<Handle>(GetReg32(system, 1)); + out_context = Convert<uint32_t>(GetArg32(args, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> thread_id_gather{}; - thread_id_gather[0] = GetReg32(system, 2); - thread_id_gather[1] = GetReg32(system, 3); + thread_id_gather[0] = GetArg32(args, 2); + thread_id_gather[1] = GetArg32(args, 3); thread_id = Convert<uint64_t>(thread_id_gather); - context_flags = Convert<uint32_t>(GetReg32(system, 4)); + context_flags = Convert<uint32_t>(GetArg32(args, 4)); ret = GetDebugThreadContext64From32(system, out_context, debug_handle, thread_id, context_flags); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) { +static void SvcWrap_SetDebugThreadContext64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -1630,20 +1630,20 @@ static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) { uint32_t context{}; uint32_t context_flags{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> thread_id_gather{}; - thread_id_gather[0] = GetReg32(system, 2); - thread_id_gather[1] = GetReg32(system, 3); + thread_id_gather[0] = GetArg32(args, 2); + thread_id_gather[1] = GetArg32(args, 3); thread_id = Convert<uint64_t>(thread_id_gather); - context = Convert<uint32_t>(GetReg32(system, 1)); - context_flags = Convert<uint32_t>(GetReg32(system, 4)); + context = Convert<uint32_t>(GetArg32(args, 1)); + context_flags = Convert<uint32_t>(GetArg32(args, 4)); ret = SetDebugThreadContext64From32(system, debug_handle, thread_id, context, context_flags); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) { +static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -1651,17 +1651,17 @@ static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) { Handle process_handle{}; uint32_t address{}; - out_memory_info = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 2)); - address = Convert<uint32_t>(GetReg32(system, 3)); + out_memory_info = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 2)); + address = Convert<uint32_t>(GetArg32(args, 3)); ret = QueryDebugProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_page_info)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_page_info)); } -static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) { +static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t buffer{}; @@ -1669,17 +1669,17 @@ static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) { uint32_t address{}; uint32_t size{}; - buffer = Convert<uint32_t>(GetReg32(system, 0)); - debug_handle = Convert<Handle>(GetReg32(system, 1)); - address = Convert<uint32_t>(GetReg32(system, 2)); - size = Convert<uint32_t>(GetReg32(system, 3)); + buffer = Convert<uint32_t>(GetArg32(args, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 1)); + address = Convert<uint32_t>(GetArg32(args, 2)); + size = Convert<uint32_t>(GetArg32(args, 3)); ret = ReadDebugProcessMemory64From32(system, buffer, debug_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) { +static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -1687,39 +1687,39 @@ static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) { uint32_t address{}; uint32_t size{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); - buffer = Convert<uint32_t>(GetReg32(system, 1)); - address = Convert<uint32_t>(GetReg32(system, 2)); - size = Convert<uint32_t>(GetReg32(system, 3)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); + buffer = Convert<uint32_t>(GetArg32(args, 1)); + address = Convert<uint32_t>(GetArg32(args, 2)); + size = Convert<uint32_t>(GetArg32(args, 3)); ret = WriteDebugProcessMemory64From32(system, debug_handle, buffer, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system) { +static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; HardwareBreakPointRegisterName name{}; uint64_t flags{}; uint64_t value{}; - name = Convert<HardwareBreakPointRegisterName>(GetReg32(system, 0)); + name = Convert<HardwareBreakPointRegisterName>(GetArg32(args, 0)); std::array<uint32_t, 2> flags_gather{}; - flags_gather[0] = GetReg32(system, 2); - flags_gather[1] = GetReg32(system, 3); + flags_gather[0] = GetArg32(args, 2); + flags_gather[1] = GetArg32(args, 3); flags = Convert<uint64_t>(flags_gather); std::array<uint32_t, 2> value_gather{}; - value_gather[0] = GetReg32(system, 1); - value_gather[1] = GetReg32(system, 4); + value_gather[0] = GetArg32(args, 1); + value_gather[1] = GetArg32(args, 4); value = Convert<uint64_t>(value_gather); ret = SetHardwareBreakPoint64From32(system, name, flags, value); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) { +static void SvcWrap_GetDebugThreadParam64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_64{}; @@ -1728,23 +1728,23 @@ static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) { uint64_t thread_id{}; DebugThreadParam param{}; - debug_handle = Convert<Handle>(GetReg32(system, 2)); + debug_handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> thread_id_gather{}; - thread_id_gather[0] = GetReg32(system, 0); - thread_id_gather[1] = GetReg32(system, 1); + thread_id_gather[0] = GetArg32(args, 0); + thread_id_gather[1] = GetArg32(args, 1); thread_id = Convert<uint64_t>(thread_id_gather); - param = Convert<DebugThreadParam>(GetReg32(system, 3)); + param = Convert<DebugThreadParam>(GetArg32(args, 3)); ret = GetDebugThreadParam64From32(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_64_scatter = Convert<std::array<uint32_t, 2>>(out_64); - SetReg32(system, 1, out_64_scatter[0]); - SetReg32(system, 2, out_64_scatter[1]); - SetReg32(system, 3, Convert<uint32_t>(out_32)); + SetArg32(args, 1, out_64_scatter[0]); + SetArg32(args, 2, out_64_scatter[1]); + SetArg32(args, 3, Convert<uint32_t>(out_32)); } -static void SvcWrap_GetSystemInfo64From32(Core::System& system) { +static void SvcWrap_GetSystemInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -1752,22 +1752,22 @@ static void SvcWrap_GetSystemInfo64From32(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<SystemInfoType>(GetReg32(system, 1)); - handle = Convert<Handle>(GetReg32(system, 2)); + info_type = Convert<SystemInfoType>(GetArg32(args, 1)); + handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> info_subtype_gather{}; - info_subtype_gather[0] = GetReg32(system, 0); - info_subtype_gather[1] = GetReg32(system, 3); + info_subtype_gather[0] = GetArg32(args, 0); + info_subtype_gather[1] = GetArg32(args, 3); info_subtype = Convert<uint64_t>(info_subtype_gather); ret = GetSystemInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_scatter = Convert<std::array<uint32_t, 2>>(out); - SetReg32(system, 1, out_scatter[0]); - SetReg32(system, 2, out_scatter[1]); + SetArg32(args, 1, out_scatter[0]); + SetArg32(args, 2, out_scatter[1]); } -static void SvcWrap_CreatePort64From32(Core::System& system) { +static void SvcWrap_CreatePort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; @@ -1776,48 +1776,48 @@ static void SvcWrap_CreatePort64From32(Core::System& system) { bool is_light{}; uint32_t name{}; - max_sessions = Convert<int32_t>(GetReg32(system, 2)); - is_light = Convert<bool>(GetReg32(system, 3)); - name = Convert<uint32_t>(GetReg32(system, 0)); + max_sessions = Convert<int32_t>(GetArg32(args, 2)); + is_light = Convert<bool>(GetArg32(args, 3)); + name = Convert<uint32_t>(GetArg32(args, 0)); ret = CreatePort64From32(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_server_handle)); - SetReg32(system, 2, Convert<uint32_t>(out_client_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_server_handle)); + SetArg32(args, 2, Convert<uint32_t>(out_client_handle)); } -static void SvcWrap_ManageNamedPort64From32(Core::System& system) { +static void SvcWrap_ManageNamedPort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; uint32_t name{}; int32_t max_sessions{}; - name = Convert<uint32_t>(GetReg32(system, 1)); - max_sessions = Convert<int32_t>(GetReg32(system, 2)); + name = Convert<uint32_t>(GetArg32(args, 1)); + max_sessions = Convert<int32_t>(GetArg32(args, 2)); ret = ManageNamedPort64From32(system, std::addressof(out_server_handle), name, max_sessions); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_server_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_server_handle)); } -static void SvcWrap_ConnectToPort64From32(Core::System& system) { +static void SvcWrap_ConnectToPort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg32(system, 1)); + port = Convert<Handle>(GetArg32(args, 1)); ret = ConnectToPort64From32(system, std::addressof(out_handle), port); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) { +static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1825,23 +1825,23 @@ static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); - perm = Convert<MemoryPermission>(GetReg32(system, 5)); + perm = Convert<MemoryPermission>(GetArg32(args, 5)); ret = SetProcessMemoryPermission64From32(system, process_handle, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapProcessMemory64From32(Core::System& system) { +static void SvcWrap_MapProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; @@ -1849,20 +1849,20 @@ static void SvcWrap_MapProcessMemory64From32(Core::System& system) { uint64_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 2); - src_address_gather[1] = GetReg32(system, 3); + src_address_gather[0] = GetArg32(args, 2); + src_address_gather[1] = GetArg32(args, 3); src_address = Convert<uint64_t>(src_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); ret = MapProcessMemory64From32(system, dst_address, process_handle, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) { +static void SvcWrap_UnmapProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; @@ -1870,20 +1870,20 @@ static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) { uint64_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 2); - src_address_gather[1] = GetReg32(system, 3); + src_address_gather[0] = GetArg32(args, 2); + src_address_gather[1] = GetArg32(args, 3); src_address = Convert<uint64_t>(src_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); ret = UnmapProcessMemory64From32(system, dst_address, process_handle, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_QueryProcessMemory64From32(Core::System& system) { +static void SvcWrap_QueryProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -1891,20 +1891,20 @@ static void SvcWrap_QueryProcessMemory64From32(Core::System& system) { Handle process_handle{}; uint64_t address{}; - out_memory_info = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 2)); + out_memory_info = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 1); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 1); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); ret = QueryProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_page_info)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_page_info)); } -static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) { +static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1912,26 +1912,26 @@ static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> dst_address_gather{}; - dst_address_gather[0] = GetReg32(system, 2); - dst_address_gather[1] = GetReg32(system, 3); + dst_address_gather[0] = GetArg32(args, 2); + dst_address_gather[1] = GetArg32(args, 3); dst_address = Convert<uint64_t>(dst_address_gather); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 1); - src_address_gather[1] = GetReg32(system, 4); + src_address_gather[0] = GetArg32(args, 1); + src_address_gather[1] = GetArg32(args, 4); src_address = Convert<uint64_t>(src_address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 5); - size_gather[1] = GetReg32(system, 6); + size_gather[0] = GetArg32(args, 5); + size_gather[1] = GetArg32(args, 6); size = Convert<uint64_t>(size_gather); ret = MapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) { +static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1939,26 +1939,26 @@ static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> dst_address_gather{}; - dst_address_gather[0] = GetReg32(system, 2); - dst_address_gather[1] = GetReg32(system, 3); + dst_address_gather[0] = GetArg32(args, 2); + dst_address_gather[1] = GetArg32(args, 3); dst_address = Convert<uint64_t>(dst_address_gather); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 1); - src_address_gather[1] = GetReg32(system, 4); + src_address_gather[0] = GetArg32(args, 1); + src_address_gather[1] = GetArg32(args, 4); src_address = Convert<uint64_t>(src_address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 5); - size_gather[1] = GetReg32(system, 6); + size_gather[0] = GetArg32(args, 5); + size_gather[1] = GetArg32(args, 6); size = Convert<uint64_t>(size_gather); ret = UnmapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateProcess64From32(Core::System& system) { +static void SvcWrap_CreateProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -1966,17 +1966,17 @@ static void SvcWrap_CreateProcess64From32(Core::System& system) { uint32_t caps{}; int32_t num_caps{}; - parameters = Convert<uint32_t>(GetReg32(system, 1)); - caps = Convert<uint32_t>(GetReg32(system, 2)); - num_caps = Convert<int32_t>(GetReg32(system, 3)); + parameters = Convert<uint32_t>(GetArg32(args, 1)); + caps = Convert<uint32_t>(GetArg32(args, 2)); + num_caps = Convert<int32_t>(GetArg32(args, 3)); ret = CreateProcess64From32(system, std::addressof(out_handle), parameters, caps, num_caps); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_StartProcess64From32(Core::System& system) { +static void SvcWrap_StartProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1984,138 +1984,138 @@ static void SvcWrap_StartProcess64From32(Core::System& system) { int32_t core_id{}; uint64_t main_thread_stack_size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); - priority = Convert<int32_t>(GetReg32(system, 1)); - core_id = Convert<int32_t>(GetReg32(system, 2)); + process_handle = Convert<Handle>(GetArg32(args, 0)); + priority = Convert<int32_t>(GetArg32(args, 1)); + core_id = Convert<int32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> main_thread_stack_size_gather{}; - main_thread_stack_size_gather[0] = GetReg32(system, 3); - main_thread_stack_size_gather[1] = GetReg32(system, 4); + main_thread_stack_size_gather[0] = GetArg32(args, 3); + main_thread_stack_size_gather[1] = GetArg32(args, 4); main_thread_stack_size = Convert<uint64_t>(main_thread_stack_size_gather); ret = StartProcess64From32(system, process_handle, priority, core_id, main_thread_stack_size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_TerminateProcess64From32(Core::System& system) { +static void SvcWrap_TerminateProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); ret = TerminateProcess64From32(system, process_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetProcessInfo64From32(Core::System& system) { +static void SvcWrap_GetProcessInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_info{}; Handle process_handle{}; ProcessInfoType info_type{}; - process_handle = Convert<Handle>(GetReg32(system, 1)); - info_type = Convert<ProcessInfoType>(GetReg32(system, 2)); + process_handle = Convert<Handle>(GetArg32(args, 1)); + info_type = Convert<ProcessInfoType>(GetArg32(args, 2)); ret = GetProcessInfo64From32(system, std::addressof(out_info), process_handle, info_type); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_info_scatter = Convert<std::array<uint32_t, 2>>(out_info); - SetReg32(system, 1, out_info_scatter[0]); - SetReg32(system, 2, out_info_scatter[1]); + SetArg32(args, 1, out_info_scatter[0]); + SetArg32(args, 2, out_info_scatter[1]); } -static void SvcWrap_CreateResourceLimit64From32(Core::System& system) { +static void SvcWrap_CreateResourceLimit64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; ret = CreateResourceLimit64From32(system, std::addressof(out_handle)); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system) { +static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle resource_limit_handle{}; LimitableResource which{}; int64_t limit_value{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 0)); - which = Convert<LimitableResource>(GetReg32(system, 1)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 0)); + which = Convert<LimitableResource>(GetArg32(args, 1)); std::array<uint32_t, 2> limit_value_gather{}; - limit_value_gather[0] = GetReg32(system, 2); - limit_value_gather[1] = GetReg32(system, 3); + limit_value_gather[0] = GetArg32(args, 2); + limit_value_gather[1] = GetArg32(args, 3); limit_value = Convert<int64_t>(limit_value_gather); ret = SetResourceLimitLimitValue64From32(system, resource_limit_handle, which, limit_value); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapInsecureMemory64From32(Core::System& system) { +static void SvcWrap_MapInsecureMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = MapInsecureMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system) { +static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = UnmapInsecureMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetHeapSize64(Core::System& system) { +static void SvcWrap_SetHeapSize64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; uint64_t size{}; - size = Convert<uint64_t>(GetReg64(system, 1)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = SetHeapSize64(system, std::addressof(out_address), size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_address)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_address)); } -static void SvcWrap_SetMemoryPermission64(Core::System& system) { +static void SvcWrap_SetMemoryPermission64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; MemoryPermission perm{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); - perm = Convert<MemoryPermission>(GetReg64(system, 2)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); + perm = Convert<MemoryPermission>(GetArg64(args, 2)); ret = SetMemoryPermission64(system, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetMemoryAttribute64(Core::System& system) { +static void SvcWrap_SetMemoryAttribute64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2123,69 +2123,69 @@ static void SvcWrap_SetMemoryAttribute64(Core::System& system) { uint32_t mask{}; uint32_t attr{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); - mask = Convert<uint32_t>(GetReg64(system, 2)); - attr = Convert<uint32_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); + mask = Convert<uint32_t>(GetArg64(args, 2)); + attr = Convert<uint32_t>(GetArg64(args, 3)); ret = SetMemoryAttribute64(system, address, size, mask, attr); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapMemory64(Core::System& system) { +static void SvcWrap_MapMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - src_address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + src_address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = MapMemory64(system, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapMemory64(Core::System& system) { +static void SvcWrap_UnmapMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - src_address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + src_address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapMemory64(system, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_QueryMemory64(Core::System& system) { +static void SvcWrap_QueryMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; uint64_t out_memory_info{}; uint64_t address{}; - out_memory_info = Convert<uint64_t>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 2)); + out_memory_info = Convert<uint64_t>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 2)); ret = QueryMemory64(system, out_memory_info, std::addressof(out_page_info), address); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_page_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_page_info)); } -static void SvcWrap_ExitProcess64(Core::System& system) { +static void SvcWrap_ExitProcess64(Core::System& system, std::span<uint64_t, 8> args) { ExitProcess64(system); } -static void SvcWrap_CreateThread64(Core::System& system) { +static void SvcWrap_CreateThread64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -2195,135 +2195,135 @@ static void SvcWrap_CreateThread64(Core::System& system) { int32_t priority{}; int32_t core_id{}; - func = Convert<uint64_t>(GetReg64(system, 1)); - arg = Convert<uint64_t>(GetReg64(system, 2)); - stack_bottom = Convert<uint64_t>(GetReg64(system, 3)); - priority = Convert<int32_t>(GetReg64(system, 4)); - core_id = Convert<int32_t>(GetReg64(system, 5)); + func = Convert<uint64_t>(GetArg64(args, 1)); + arg = Convert<uint64_t>(GetArg64(args, 2)); + stack_bottom = Convert<uint64_t>(GetArg64(args, 3)); + priority = Convert<int32_t>(GetArg64(args, 4)); + core_id = Convert<int32_t>(GetArg64(args, 5)); ret = CreateThread64(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_StartThread64(Core::System& system) { +static void SvcWrap_StartThread64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); ret = StartThread64(system, thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ExitThread64(Core::System& system) { +static void SvcWrap_ExitThread64(Core::System& system, std::span<uint64_t, 8> args) { ExitThread64(system); } -static void SvcWrap_SleepThread64(Core::System& system) { +static void SvcWrap_SleepThread64(Core::System& system, std::span<uint64_t, 8> args) { int64_t ns{}; - ns = Convert<int64_t>(GetReg64(system, 0)); + ns = Convert<int64_t>(GetArg64(args, 0)); SleepThread64(system, ns); } -static void SvcWrap_GetThreadPriority64(Core::System& system) { +static void SvcWrap_GetThreadPriority64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_priority{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetThreadPriority64(system, std::addressof(out_priority), thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_priority)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_priority)); } -static void SvcWrap_SetThreadPriority64(Core::System& system) { +static void SvcWrap_SetThreadPriority64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t priority{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - priority = Convert<int32_t>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + priority = Convert<int32_t>(GetArg64(args, 1)); ret = SetThreadPriority64(system, thread_handle, priority); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetThreadCoreMask64(Core::System& system) { +static void SvcWrap_GetThreadCoreMask64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_core_id{}; uint64_t out_affinity_mask{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 2)); + thread_handle = Convert<Handle>(GetArg64(args, 2)); ret = GetThreadCoreMask64(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_core_id)); - SetReg64(system, 2, Convert<uint64_t>(out_affinity_mask)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_core_id)); + SetArg64(args, 2, Convert<uint64_t>(out_affinity_mask)); } -static void SvcWrap_SetThreadCoreMask64(Core::System& system) { +static void SvcWrap_SetThreadCoreMask64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t core_id{}; uint64_t affinity_mask{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - core_id = Convert<int32_t>(GetReg64(system, 1)); - affinity_mask = Convert<uint64_t>(GetReg64(system, 2)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + core_id = Convert<int32_t>(GetArg64(args, 1)); + affinity_mask = Convert<uint64_t>(GetArg64(args, 2)); ret = SetThreadCoreMask64(system, thread_handle, core_id, affinity_mask); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system) { +static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system, std::span<uint64_t, 8> args) { int32_t ret{}; ret = GetCurrentProcessorNumber64(system); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SignalEvent64(Core::System& system) { +static void SvcWrap_SignalEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg64(system, 0)); + event_handle = Convert<Handle>(GetArg64(args, 0)); ret = SignalEvent64(system, event_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ClearEvent64(Core::System& system) { +static void SvcWrap_ClearEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg64(system, 0)); + event_handle = Convert<Handle>(GetArg64(args, 0)); ret = ClearEvent64(system, event_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapSharedMemory64(Core::System& system) { +static void SvcWrap_MapSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; @@ -2331,33 +2331,33 @@ static void SvcWrap_MapSharedMemory64(Core::System& system) { uint64_t size{}; MemoryPermission map_perm{}; - shmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + shmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = MapSharedMemory64(system, shmem_handle, address, size, map_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapSharedMemory64(Core::System& system) { +static void SvcWrap_UnmapSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; uint64_t address{}; uint64_t size{}; - shmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + shmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapSharedMemory64(system, shmem_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateTransferMemory64(Core::System& system) { +static void SvcWrap_CreateTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -2365,41 +2365,41 @@ static void SvcWrap_CreateTransferMemory64(Core::System& system) { uint64_t size{}; MemoryPermission map_perm{}; - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = CreateTransferMemory64(system, std::addressof(out_handle), address, size, map_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_CloseHandle64(Core::System& system) { +static void SvcWrap_CloseHandle64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg64(system, 0)); + handle = Convert<Handle>(GetArg64(args, 0)); ret = CloseHandle64(system, handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ResetSignal64(Core::System& system) { +static void SvcWrap_ResetSignal64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg64(system, 0)); + handle = Convert<Handle>(GetArg64(args, 0)); ret = ResetSignal64(system, handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WaitSynchronization64(Core::System& system) { +static void SvcWrap_WaitSynchronization64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -2407,57 +2407,57 @@ static void SvcWrap_WaitSynchronization64(Core::System& system) { int32_t num_handles{}; int64_t timeout_ns{}; - handles = Convert<uint64_t>(GetReg64(system, 1)); - num_handles = Convert<int32_t>(GetReg64(system, 2)); - timeout_ns = Convert<int64_t>(GetReg64(system, 3)); + handles = Convert<uint64_t>(GetArg64(args, 1)); + num_handles = Convert<int32_t>(GetArg64(args, 2)); + timeout_ns = Convert<int64_t>(GetArg64(args, 3)); ret = WaitSynchronization64(system, std::addressof(out_index), handles, num_handles, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_index)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_index)); } -static void SvcWrap_CancelSynchronization64(Core::System& system) { +static void SvcWrap_CancelSynchronization64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg64(system, 0)); + handle = Convert<Handle>(GetArg64(args, 0)); ret = CancelSynchronization64(system, handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ArbitrateLock64(Core::System& system) { +static void SvcWrap_ArbitrateLock64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; uint64_t address{}; uint32_t tag{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - tag = Convert<uint32_t>(GetReg64(system, 2)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + tag = Convert<uint32_t>(GetArg64(args, 2)); ret = ArbitrateLock64(system, thread_handle, address, tag); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ArbitrateUnlock64(Core::System& system) { +static void SvcWrap_ArbitrateUnlock64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; - address = Convert<uint64_t>(GetReg64(system, 0)); + address = Convert<uint64_t>(GetArg64(args, 0)); ret = ArbitrateUnlock64(system, address); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) { +static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2465,77 +2465,77 @@ static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) { uint32_t tag{}; int64_t timeout_ns{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - cv_key = Convert<uint64_t>(GetReg64(system, 1)); - tag = Convert<uint32_t>(GetReg64(system, 2)); - timeout_ns = Convert<int64_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + cv_key = Convert<uint64_t>(GetArg64(args, 1)); + tag = Convert<uint32_t>(GetArg64(args, 2)); + timeout_ns = Convert<int64_t>(GetArg64(args, 3)); ret = WaitProcessWideKeyAtomic64(system, address, cv_key, tag, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SignalProcessWideKey64(Core::System& system) { +static void SvcWrap_SignalProcessWideKey64(Core::System& system, std::span<uint64_t, 8> args) { uint64_t cv_key{}; int32_t count{}; - cv_key = Convert<uint64_t>(GetReg64(system, 0)); - count = Convert<int32_t>(GetReg64(system, 1)); + cv_key = Convert<uint64_t>(GetArg64(args, 0)); + count = Convert<int32_t>(GetArg64(args, 1)); SignalProcessWideKey64(system, cv_key, count); } -static void SvcWrap_GetSystemTick64(Core::System& system) { +static void SvcWrap_GetSystemTick64(Core::System& system, std::span<uint64_t, 8> args) { int64_t ret{}; ret = GetSystemTick64(system); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ConnectToNamedPort64(Core::System& system) { +static void SvcWrap_ConnectToNamedPort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t name{}; - name = Convert<uint64_t>(GetReg64(system, 1)); + name = Convert<uint64_t>(GetArg64(args, 1)); ret = ConnectToNamedPort64(system, std::addressof(out_handle), name); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_SendSyncRequest64(Core::System& system) { +static void SvcWrap_SendSyncRequest64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle session_handle{}; - session_handle = Convert<Handle>(GetReg64(system, 0)); + session_handle = Convert<Handle>(GetArg64(args, 0)); ret = SendSyncRequest64(system, session_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system) { +static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t message_buffer{}; uint64_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint64_t>(GetReg64(system, 0)); - message_buffer_size = Convert<uint64_t>(GetReg64(system, 1)); - session_handle = Convert<Handle>(GetReg64(system, 2)); + message_buffer = Convert<uint64_t>(GetArg64(args, 0)); + message_buffer_size = Convert<uint64_t>(GetArg64(args, 1)); + session_handle = Convert<Handle>(GetArg64(args, 2)); ret = SendSyncRequestWithUserBuffer64(system, message_buffer, message_buffer_size, session_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) { +static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_event_handle{}; @@ -2543,79 +2543,79 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) { uint64_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint64_t>(GetReg64(system, 1)); - message_buffer_size = Convert<uint64_t>(GetReg64(system, 2)); - session_handle = Convert<Handle>(GetReg64(system, 3)); + message_buffer = Convert<uint64_t>(GetArg64(args, 1)); + message_buffer_size = Convert<uint64_t>(GetArg64(args, 2)); + session_handle = Convert<Handle>(GetArg64(args, 3)); ret = SendAsyncRequestWithUserBuffer64(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_event_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_event_handle)); } -static void SvcWrap_GetProcessId64(Core::System& system) { +static void SvcWrap_GetProcessId64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_process_id{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg64(system, 1)); + process_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetProcessId64(system, std::addressof(out_process_id), process_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_process_id)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_process_id)); } -static void SvcWrap_GetThreadId64(Core::System& system) { +static void SvcWrap_GetThreadId64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_thread_id{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetThreadId64(system, std::addressof(out_thread_id), thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_thread_id)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_thread_id)); } -static void SvcWrap_Break64(Core::System& system) { +static void SvcWrap_Break64(Core::System& system, std::span<uint64_t, 8> args) { BreakReason break_reason{}; uint64_t arg{}; uint64_t size{}; - break_reason = Convert<BreakReason>(GetReg64(system, 0)); - arg = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + break_reason = Convert<BreakReason>(GetArg64(args, 0)); + arg = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); Break64(system, break_reason, arg, size); } -static void SvcWrap_OutputDebugString64(Core::System& system) { +static void SvcWrap_OutputDebugString64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t debug_str{}; uint64_t len{}; - debug_str = Convert<uint64_t>(GetReg64(system, 0)); - len = Convert<uint64_t>(GetReg64(system, 1)); + debug_str = Convert<uint64_t>(GetArg64(args, 0)); + len = Convert<uint64_t>(GetArg64(args, 1)); ret = OutputDebugString64(system, debug_str, len); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ReturnFromException64(Core::System& system) { +static void SvcWrap_ReturnFromException64(Core::System& system, std::span<uint64_t, 8> args) { Result result{}; - result = Convert<Result>(GetReg64(system, 0)); + result = Convert<Result>(GetArg64(args, 0)); ReturnFromException64(system, result); } -static void SvcWrap_GetInfo64(Core::System& system) { +static void SvcWrap_GetInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -2623,63 +2623,63 @@ static void SvcWrap_GetInfo64(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<InfoType>(GetReg64(system, 1)); - handle = Convert<Handle>(GetReg64(system, 2)); - info_subtype = Convert<uint64_t>(GetReg64(system, 3)); + info_type = Convert<InfoType>(GetArg64(args, 1)); + handle = Convert<Handle>(GetArg64(args, 2)); + info_subtype = Convert<uint64_t>(GetArg64(args, 3)); ret = GetInfo64(system, std::addressof(out), info_type, handle, info_subtype); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out)); } -static void SvcWrap_FlushEntireDataCache64(Core::System& system) { +static void SvcWrap_FlushEntireDataCache64(Core::System& system, std::span<uint64_t, 8> args) { FlushEntireDataCache64(system); } -static void SvcWrap_FlushDataCache64(Core::System& system) { +static void SvcWrap_FlushDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = FlushDataCache64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapPhysicalMemory64(Core::System& system) { +static void SvcWrap_MapPhysicalMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = MapPhysicalMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemory64(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = UnmapPhysicalMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) { +static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; lp64::LastThreadContext out_context{}; @@ -2687,21 +2687,21 @@ static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) { Handle debug_handle{}; int64_t ns{}; - debug_handle = Convert<Handle>(GetReg64(system, 2)); - ns = Convert<int64_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 2)); + ns = Convert<int64_t>(GetArg64(args, 3)); ret = GetDebugFutureThreadInfo64(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context); - SetReg64(system, 1, out_context_scatter[0]); - SetReg64(system, 2, out_context_scatter[1]); - SetReg64(system, 3, out_context_scatter[2]); - SetReg64(system, 4, out_context_scatter[3]); - SetReg64(system, 5, Convert<uint64_t>(out_thread_id)); + SetArg64(args, 1, out_context_scatter[0]); + SetArg64(args, 2, out_context_scatter[1]); + SetArg64(args, 3, out_context_scatter[2]); + SetArg64(args, 4, out_context_scatter[3]); + SetArg64(args, 5, Convert<uint64_t>(out_thread_id)); } -static void SvcWrap_GetLastThreadInfo64(Core::System& system) { +static void SvcWrap_GetLastThreadInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; lp64::LastThreadContext out_context{}; @@ -2710,77 +2710,77 @@ static void SvcWrap_GetLastThreadInfo64(Core::System& system) { ret = GetLastThreadInfo64(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context); - SetReg64(system, 1, out_context_scatter[0]); - SetReg64(system, 2, out_context_scatter[1]); - SetReg64(system, 3, out_context_scatter[2]); - SetReg64(system, 4, out_context_scatter[3]); - SetReg64(system, 5, Convert<uint64_t>(out_tls_address)); - SetReg64(system, 6, Convert<uint64_t>(out_flags)); + SetArg64(args, 1, out_context_scatter[0]); + SetArg64(args, 2, out_context_scatter[1]); + SetArg64(args, 3, out_context_scatter[2]); + SetArg64(args, 4, out_context_scatter[3]); + SetArg64(args, 5, Convert<uint64_t>(out_tls_address)); + SetArg64(args, 6, Convert<uint64_t>(out_flags)); } -static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system) { +static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_limit_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); - which = Convert<LimitableResource>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 1)); + which = Convert<LimitableResource>(GetArg64(args, 2)); ret = GetResourceLimitLimitValue64(system, std::addressof(out_limit_value), resource_limit_handle, which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_limit_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_limit_value)); } -static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system) { +static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_current_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); - which = Convert<LimitableResource>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 1)); + which = Convert<LimitableResource>(GetArg64(args, 2)); ret = GetResourceLimitCurrentValue64(system, std::addressof(out_current_value), resource_limit_handle, which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_current_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_current_value)); } -static void SvcWrap_SetThreadActivity64(Core::System& system) { +static void SvcWrap_SetThreadActivity64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; ThreadActivity thread_activity{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - thread_activity = Convert<ThreadActivity>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + thread_activity = Convert<ThreadActivity>(GetArg64(args, 1)); ret = SetThreadActivity64(system, thread_handle, thread_activity); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetThreadContext364(Core::System& system) { +static void SvcWrap_GetThreadContext364(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_context{}; Handle thread_handle{}; - out_context = Convert<uint64_t>(GetReg64(system, 0)); - thread_handle = Convert<Handle>(GetReg64(system, 1)); + out_context = Convert<uint64_t>(GetArg64(args, 0)); + thread_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetThreadContext364(system, out_context, thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WaitForAddress64(Core::System& system) { +static void SvcWrap_WaitForAddress64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2788,17 +2788,17 @@ static void SvcWrap_WaitForAddress64(Core::System& system) { int32_t value{}; int64_t timeout_ns{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - arb_type = Convert<ArbitrationType>(GetReg64(system, 1)); - value = Convert<int32_t>(GetReg64(system, 2)); - timeout_ns = Convert<int64_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + arb_type = Convert<ArbitrationType>(GetArg64(args, 1)); + value = Convert<int32_t>(GetArg64(args, 2)); + timeout_ns = Convert<int64_t>(GetArg64(args, 3)); ret = WaitForAddress64(system, address, arb_type, value, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SignalToAddress64(Core::System& system) { +static void SvcWrap_SignalToAddress64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2806,51 +2806,51 @@ static void SvcWrap_SignalToAddress64(Core::System& system) { int32_t value{}; int32_t count{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - signal_type = Convert<SignalType>(GetReg64(system, 1)); - value = Convert<int32_t>(GetReg64(system, 2)); - count = Convert<int32_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + signal_type = Convert<SignalType>(GetArg64(args, 1)); + value = Convert<int32_t>(GetArg64(args, 2)); + count = Convert<int32_t>(GetArg64(args, 3)); ret = SignalToAddress64(system, address, signal_type, value, count); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SynchronizePreemptionState64(Core::System& system) { +static void SvcWrap_SynchronizePreemptionState64(Core::System& system, std::span<uint64_t, 8> args) { SynchronizePreemptionState64(system); } -static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system) { +static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_peak_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); - which = Convert<LimitableResource>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 1)); + which = Convert<LimitableResource>(GetArg64(args, 2)); ret = GetResourceLimitPeakValue64(system, std::addressof(out_peak_value), resource_limit_handle, which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_peak_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_peak_value)); } -static void SvcWrap_CreateIoPool64(Core::System& system) { +static void SvcWrap_CreateIoPool64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; IoPoolType which{}; - which = Convert<IoPoolType>(GetReg64(system, 1)); + which = Convert<IoPoolType>(GetArg64(args, 1)); ret = CreateIoPool64(system, std::addressof(out_handle), which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_CreateIoRegion64(Core::System& system) { +static void SvcWrap_CreateIoRegion64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -2860,41 +2860,41 @@ static void SvcWrap_CreateIoRegion64(Core::System& system) { MemoryMapping mapping{}; MemoryPermission perm{}; - io_pool = Convert<Handle>(GetReg64(system, 1)); - physical_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - mapping = Convert<MemoryMapping>(GetReg64(system, 4)); - perm = Convert<MemoryPermission>(GetReg64(system, 5)); + io_pool = Convert<Handle>(GetArg64(args, 1)); + physical_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + mapping = Convert<MemoryMapping>(GetArg64(args, 4)); + perm = Convert<MemoryPermission>(GetArg64(args, 5)); ret = CreateIoRegion64(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_KernelDebug64(Core::System& system) { +static void SvcWrap_KernelDebug64(Core::System& system, std::span<uint64_t, 8> args) { KernelDebugType kern_debug_type{}; uint64_t arg0{}; uint64_t arg1{}; uint64_t arg2{}; - kern_debug_type = Convert<KernelDebugType>(GetReg64(system, 0)); - arg0 = Convert<uint64_t>(GetReg64(system, 1)); - arg1 = Convert<uint64_t>(GetReg64(system, 2)); - arg2 = Convert<uint64_t>(GetReg64(system, 3)); + kern_debug_type = Convert<KernelDebugType>(GetArg64(args, 0)); + arg0 = Convert<uint64_t>(GetArg64(args, 1)); + arg1 = Convert<uint64_t>(GetArg64(args, 2)); + arg2 = Convert<uint64_t>(GetArg64(args, 3)); KernelDebug64(system, kern_debug_type, arg0, arg1, arg2); } -static void SvcWrap_ChangeKernelTraceState64(Core::System& system) { +static void SvcWrap_ChangeKernelTraceState64(Core::System& system, std::span<uint64_t, 8> args) { KernelTraceState kern_trace_state{}; - kern_trace_state = Convert<KernelTraceState>(GetReg64(system, 0)); + kern_trace_state = Convert<KernelTraceState>(GetArg64(args, 0)); ChangeKernelTraceState64(system, kern_trace_state); } -static void SvcWrap_CreateSession64(Core::System& system) { +static void SvcWrap_CreateSession64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_session_handle{}; @@ -2902,31 +2902,31 @@ static void SvcWrap_CreateSession64(Core::System& system) { bool is_light{}; uint64_t name{}; - is_light = Convert<bool>(GetReg64(system, 2)); - name = Convert<uint64_t>(GetReg64(system, 3)); + is_light = Convert<bool>(GetArg64(args, 2)); + name = Convert<uint64_t>(GetArg64(args, 3)); ret = CreateSession64(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_server_session_handle)); - SetReg64(system, 2, Convert<uint64_t>(out_client_session_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_server_session_handle)); + SetArg64(args, 2, Convert<uint64_t>(out_client_session_handle)); } -static void SvcWrap_AcceptSession64(Core::System& system) { +static void SvcWrap_AcceptSession64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg64(system, 1)); + port = Convert<Handle>(GetArg64(args, 1)); ret = AcceptSession64(system, std::addressof(out_handle), port); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_ReplyAndReceive64(Core::System& system) { +static void SvcWrap_ReplyAndReceive64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -2935,18 +2935,18 @@ static void SvcWrap_ReplyAndReceive64(Core::System& system) { Handle reply_target{}; int64_t timeout_ns{}; - handles = Convert<uint64_t>(GetReg64(system, 1)); - num_handles = Convert<int32_t>(GetReg64(system, 2)); - reply_target = Convert<Handle>(GetReg64(system, 3)); - timeout_ns = Convert<int64_t>(GetReg64(system, 4)); + handles = Convert<uint64_t>(GetArg64(args, 1)); + num_handles = Convert<int32_t>(GetArg64(args, 2)); + reply_target = Convert<Handle>(GetArg64(args, 3)); + timeout_ns = Convert<int64_t>(GetArg64(args, 4)); ret = ReplyAndReceive64(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_index)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_index)); } -static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) { +static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -2957,20 +2957,20 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) { Handle reply_target{}; int64_t timeout_ns{}; - message_buffer = Convert<uint64_t>(GetReg64(system, 1)); - message_buffer_size = Convert<uint64_t>(GetReg64(system, 2)); - handles = Convert<uint64_t>(GetReg64(system, 3)); - num_handles = Convert<int32_t>(GetReg64(system, 4)); - reply_target = Convert<Handle>(GetReg64(system, 5)); - timeout_ns = Convert<int64_t>(GetReg64(system, 6)); + message_buffer = Convert<uint64_t>(GetArg64(args, 1)); + message_buffer_size = Convert<uint64_t>(GetArg64(args, 2)); + handles = Convert<uint64_t>(GetArg64(args, 3)); + num_handles = Convert<int32_t>(GetArg64(args, 4)); + reply_target = Convert<Handle>(GetArg64(args, 5)); + timeout_ns = Convert<int64_t>(GetArg64(args, 6)); ret = ReplyAndReceiveWithUserBuffer64(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_index)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_index)); } -static void SvcWrap_CreateEvent64(Core::System& system) { +static void SvcWrap_CreateEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_write_handle{}; @@ -2978,12 +2978,12 @@ static void SvcWrap_CreateEvent64(Core::System& system) { ret = CreateEvent64(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_write_handle)); - SetReg64(system, 2, Convert<uint64_t>(out_read_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_write_handle)); + SetArg64(args, 2, Convert<uint64_t>(out_read_handle)); } -static void SvcWrap_MapIoRegion64(Core::System& system) { +static void SvcWrap_MapIoRegion64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; @@ -2991,89 +2991,89 @@ static void SvcWrap_MapIoRegion64(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - io_region = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - perm = Convert<MemoryPermission>(GetReg64(system, 3)); + io_region = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = MapIoRegion64(system, io_region, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapIoRegion64(Core::System& system) { +static void SvcWrap_UnmapIoRegion64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; uint64_t address{}; uint64_t size{}; - io_region = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + io_region = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapIoRegion64(system, io_region, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system) { +static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = MapPhysicalMemoryUnsafe64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = UnmapPhysicalMemoryUnsafe64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetUnsafeLimit64(Core::System& system) { +static void SvcWrap_SetUnsafeLimit64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t limit{}; - limit = Convert<uint64_t>(GetReg64(system, 0)); + limit = Convert<uint64_t>(GetArg64(args, 0)); ret = SetUnsafeLimit64(system, limit); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateCodeMemory64(Core::System& system) { +static void SvcWrap_CreateCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = CreateCodeMemory64(system, std::addressof(out_handle), address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_ControlCodeMemory64(Core::System& system) { +static void SvcWrap_ControlCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle code_memory_handle{}; @@ -3082,22 +3082,22 @@ static void SvcWrap_ControlCodeMemory64(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - code_memory_handle = Convert<Handle>(GetReg64(system, 0)); - operation = Convert<CodeMemoryOperation>(GetReg64(system, 1)); - address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - perm = Convert<MemoryPermission>(GetReg64(system, 4)); + code_memory_handle = Convert<Handle>(GetArg64(args, 0)); + operation = Convert<CodeMemoryOperation>(GetArg64(args, 1)); + address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + perm = Convert<MemoryPermission>(GetArg64(args, 4)); ret = ControlCodeMemory64(system, code_memory_handle, operation, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SleepSystem64(Core::System& system) { +static void SvcWrap_SleepSystem64(Core::System& system, std::span<uint64_t, 8> args) { SleepSystem64(system); } -static void SvcWrap_ReadWriteRegister64(Core::System& system) { +static void SvcWrap_ReadWriteRegister64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_value{}; @@ -3105,31 +3105,31 @@ static void SvcWrap_ReadWriteRegister64(Core::System& system) { uint32_t mask{}; uint32_t value{}; - address = Convert<uint64_t>(GetReg64(system, 1)); - mask = Convert<uint32_t>(GetReg64(system, 2)); - value = Convert<uint32_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 1)); + mask = Convert<uint32_t>(GetArg64(args, 2)); + value = Convert<uint32_t>(GetArg64(args, 3)); ret = ReadWriteRegister64(system, std::addressof(out_value), address, mask, value); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_value)); } -static void SvcWrap_SetProcessActivity64(Core::System& system) { +static void SvcWrap_SetProcessActivity64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; ProcessActivity process_activity{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - process_activity = Convert<ProcessActivity>(GetReg64(system, 1)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + process_activity = Convert<ProcessActivity>(GetArg64(args, 1)); ret = SetProcessActivity64(system, process_handle, process_activity); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateSharedMemory64(Core::System& system) { +static void SvcWrap_CreateSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -3137,17 +3137,17 @@ static void SvcWrap_CreateSharedMemory64(Core::System& system) { MemoryPermission owner_perm{}; MemoryPermission remote_perm{}; - size = Convert<uint64_t>(GetReg64(system, 1)); - owner_perm = Convert<MemoryPermission>(GetReg64(system, 2)); - remote_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + size = Convert<uint64_t>(GetArg64(args, 1)); + owner_perm = Convert<MemoryPermission>(GetArg64(args, 2)); + remote_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = CreateSharedMemory64(system, std::addressof(out_handle), size, owner_perm, remote_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_MapTransferMemory64(Core::System& system) { +static void SvcWrap_MapTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; @@ -3155,66 +3155,66 @@ static void SvcWrap_MapTransferMemory64(Core::System& system) { uint64_t size{}; MemoryPermission owner_perm{}; - trmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - owner_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + trmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + owner_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = MapTransferMemory64(system, trmem_handle, address, size, owner_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapTransferMemory64(Core::System& system) { +static void SvcWrap_UnmapTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; uint64_t address{}; uint64_t size{}; - trmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + trmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapTransferMemory64(system, trmem_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateInterruptEvent64(Core::System& system) { +static void SvcWrap_CreateInterruptEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_read_handle{}; int32_t interrupt_id{}; InterruptType interrupt_type{}; - interrupt_id = Convert<int32_t>(GetReg64(system, 1)); - interrupt_type = Convert<InterruptType>(GetReg64(system, 2)); + interrupt_id = Convert<int32_t>(GetArg64(args, 1)); + interrupt_type = Convert<InterruptType>(GetArg64(args, 2)); ret = CreateInterruptEvent64(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_read_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_read_handle)); } -static void SvcWrap_QueryPhysicalAddress64(Core::System& system) { +static void SvcWrap_QueryPhysicalAddress64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; lp64::PhysicalMemoryInfo out_info{}; uint64_t address{}; - address = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 1)); ret = QueryPhysicalAddress64(system, std::addressof(out_info), address); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); auto out_info_scatter = Convert<std::array<uint64_t, 3>>(out_info); - SetReg64(system, 1, out_info_scatter[0]); - SetReg64(system, 2, out_info_scatter[1]); - SetReg64(system, 3, out_info_scatter[2]); + SetArg64(args, 1, out_info_scatter[0]); + SetArg64(args, 2, out_info_scatter[1]); + SetArg64(args, 3, out_info_scatter[2]); } -static void SvcWrap_QueryIoMapping64(Core::System& system) { +static void SvcWrap_QueryIoMapping64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; @@ -3222,61 +3222,61 @@ static void SvcWrap_QueryIoMapping64(Core::System& system) { uint64_t physical_address{}; uint64_t size{}; - physical_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + physical_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = QueryIoMapping64(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_address)); - SetReg64(system, 2, Convert<uint64_t>(out_size)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_address)); + SetArg64(args, 2, Convert<uint64_t>(out_size)); } -static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t das_address{}; uint64_t das_size{}; - das_address = Convert<uint64_t>(GetReg64(system, 1)); - das_size = Convert<uint64_t>(GetReg64(system, 2)); + das_address = Convert<uint64_t>(GetArg64(args, 1)); + das_size = Convert<uint64_t>(GetArg64(args, 2)); ret = CreateDeviceAddressSpace64(system, std::addressof(out_handle), das_address, das_size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg64(system, 0)); - das_handle = Convert<Handle>(GetReg64(system, 1)); + device_name = Convert<DeviceName>(GetArg64(args, 0)); + das_handle = Convert<Handle>(GetArg64(args, 1)); ret = AttachDeviceAddressSpace64(system, device_name, das_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg64(system, 0)); - das_handle = Convert<Handle>(GetReg64(system, 1)); + device_name = Convert<DeviceName>(GetArg64(args, 0)); + das_handle = Convert<Handle>(GetArg64(args, 1)); ret = DetachDeviceAddressSpace64(system, device_name, das_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -3286,19 +3286,19 @@ static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - process_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - device_address = Convert<uint64_t>(GetReg64(system, 4)); - option = Convert<uint32_t>(GetReg64(system, 5)); + das_handle = Convert<Handle>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + process_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + device_address = Convert<uint64_t>(GetArg64(args, 4)); + option = Convert<uint32_t>(GetArg64(args, 5)); ret = MapDeviceAddressSpaceByForce64(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -3308,19 +3308,19 @@ static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - process_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - device_address = Convert<uint64_t>(GetReg64(system, 4)); - option = Convert<uint32_t>(GetReg64(system, 5)); + das_handle = Convert<Handle>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + process_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + device_address = Convert<uint64_t>(GetArg64(args, 4)); + option = Convert<uint32_t>(GetArg64(args, 5)); ret = MapDeviceAddressSpaceAligned64(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -3329,118 +3329,118 @@ static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) { uint64_t size{}; uint64_t device_address{}; - das_handle = Convert<Handle>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - process_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - device_address = Convert<uint64_t>(GetReg64(system, 4)); + das_handle = Convert<Handle>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + process_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + device_address = Convert<uint64_t>(GetArg64(args, 4)); ret = UnmapDeviceAddressSpace64(system, das_handle, process_handle, process_address, size, device_address); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_InvalidateProcessDataCache64(Core::System& system) { +static void SvcWrap_InvalidateProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = InvalidateProcessDataCache64(system, process_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_StoreProcessDataCache64(Core::System& system) { +static void SvcWrap_StoreProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = StoreProcessDataCache64(system, process_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_FlushProcessDataCache64(Core::System& system) { +static void SvcWrap_FlushProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = FlushProcessDataCache64(system, process_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_DebugActiveProcess64(Core::System& system) { +static void SvcWrap_DebugActiveProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t process_id{}; - process_id = Convert<uint64_t>(GetReg64(system, 1)); + process_id = Convert<uint64_t>(GetArg64(args, 1)); ret = DebugActiveProcess64(system, std::addressof(out_handle), process_id); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_BreakDebugProcess64(Core::System& system) { +static void SvcWrap_BreakDebugProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); ret = BreakDebugProcess64(system, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_TerminateDebugProcess64(Core::System& system) { +static void SvcWrap_TerminateDebugProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); ret = TerminateDebugProcess64(system, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetDebugEvent64(Core::System& system) { +static void SvcWrap_GetDebugEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_info{}; Handle debug_handle{}; - out_info = Convert<uint64_t>(GetReg64(system, 0)); - debug_handle = Convert<Handle>(GetReg64(system, 1)); + out_info = Convert<uint64_t>(GetArg64(args, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetDebugEvent64(system, out_info, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ContinueDebugEvent64(Core::System& system) { +static void SvcWrap_ContinueDebugEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -3448,33 +3448,33 @@ static void SvcWrap_ContinueDebugEvent64(Core::System& system) { uint64_t thread_ids{}; int32_t num_thread_ids{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); - flags = Convert<uint32_t>(GetReg64(system, 1)); - thread_ids = Convert<uint64_t>(GetReg64(system, 2)); - num_thread_ids = Convert<int32_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); + flags = Convert<uint32_t>(GetArg64(args, 1)); + thread_ids = Convert<uint64_t>(GetArg64(args, 2)); + num_thread_ids = Convert<int32_t>(GetArg64(args, 3)); ret = ContinueDebugEvent64(system, debug_handle, flags, thread_ids, num_thread_ids); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetProcessList64(Core::System& system) { +static void SvcWrap_GetProcessList64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_processes{}; uint64_t out_process_ids{}; int32_t max_out_count{}; - out_process_ids = Convert<uint64_t>(GetReg64(system, 1)); - max_out_count = Convert<int32_t>(GetReg64(system, 2)); + out_process_ids = Convert<uint64_t>(GetArg64(args, 1)); + max_out_count = Convert<int32_t>(GetArg64(args, 2)); ret = GetProcessList64(system, std::addressof(out_num_processes), out_process_ids, max_out_count); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_num_processes)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_num_processes)); } -static void SvcWrap_GetThreadList64(Core::System& system) { +static void SvcWrap_GetThreadList64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_threads{}; @@ -3482,17 +3482,17 @@ static void SvcWrap_GetThreadList64(Core::System& system) { int32_t max_out_count{}; Handle debug_handle{}; - out_thread_ids = Convert<uint64_t>(GetReg64(system, 1)); - max_out_count = Convert<int32_t>(GetReg64(system, 2)); - debug_handle = Convert<Handle>(GetReg64(system, 3)); + out_thread_ids = Convert<uint64_t>(GetArg64(args, 1)); + max_out_count = Convert<int32_t>(GetArg64(args, 2)); + debug_handle = Convert<Handle>(GetArg64(args, 3)); ret = GetThreadList64(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_num_threads)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_num_threads)); } -static void SvcWrap_GetDebugThreadContext64(Core::System& system) { +static void SvcWrap_GetDebugThreadContext64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_context{}; @@ -3500,17 +3500,17 @@ static void SvcWrap_GetDebugThreadContext64(Core::System& system) { uint64_t thread_id{}; uint32_t context_flags{}; - out_context = Convert<uint64_t>(GetReg64(system, 0)); - debug_handle = Convert<Handle>(GetReg64(system, 1)); - thread_id = Convert<uint64_t>(GetReg64(system, 2)); - context_flags = Convert<uint32_t>(GetReg64(system, 3)); + out_context = Convert<uint64_t>(GetArg64(args, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 1)); + thread_id = Convert<uint64_t>(GetArg64(args, 2)); + context_flags = Convert<uint32_t>(GetArg64(args, 3)); ret = GetDebugThreadContext64(system, out_context, debug_handle, thread_id, context_flags); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetDebugThreadContext64(Core::System& system) { +static void SvcWrap_SetDebugThreadContext64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -3518,17 +3518,17 @@ static void SvcWrap_SetDebugThreadContext64(Core::System& system) { uint64_t context{}; uint32_t context_flags{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); - thread_id = Convert<uint64_t>(GetReg64(system, 1)); - context = Convert<uint64_t>(GetReg64(system, 2)); - context_flags = Convert<uint32_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); + thread_id = Convert<uint64_t>(GetArg64(args, 1)); + context = Convert<uint64_t>(GetArg64(args, 2)); + context_flags = Convert<uint32_t>(GetArg64(args, 3)); ret = SetDebugThreadContext64(system, debug_handle, thread_id, context, context_flags); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) { +static void SvcWrap_QueryDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -3536,17 +3536,17 @@ static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) { Handle process_handle{}; uint64_t address{}; - out_memory_info = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 2)); - address = Convert<uint64_t>(GetReg64(system, 3)); + out_memory_info = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 2)); + address = Convert<uint64_t>(GetArg64(args, 3)); ret = QueryDebugProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_page_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_page_info)); } -static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) { +static void SvcWrap_ReadDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t buffer{}; @@ -3554,17 +3554,17 @@ static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) { uint64_t address{}; uint64_t size{}; - buffer = Convert<uint64_t>(GetReg64(system, 0)); - debug_handle = Convert<Handle>(GetReg64(system, 1)); - address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + buffer = Convert<uint64_t>(GetArg64(args, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 1)); + address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = ReadDebugProcessMemory64(system, buffer, debug_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) { +static void SvcWrap_WriteDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -3572,33 +3572,33 @@ static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) { uint64_t address{}; uint64_t size{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); - buffer = Convert<uint64_t>(GetReg64(system, 1)); - address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); + buffer = Convert<uint64_t>(GetArg64(args, 1)); + address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = WriteDebugProcessMemory64(system, debug_handle, buffer, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetHardwareBreakPoint64(Core::System& system) { +static void SvcWrap_SetHardwareBreakPoint64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; HardwareBreakPointRegisterName name{}; uint64_t flags{}; uint64_t value{}; - name = Convert<HardwareBreakPointRegisterName>(GetReg64(system, 0)); - flags = Convert<uint64_t>(GetReg64(system, 1)); - value = Convert<uint64_t>(GetReg64(system, 2)); + name = Convert<HardwareBreakPointRegisterName>(GetArg64(args, 0)); + flags = Convert<uint64_t>(GetArg64(args, 1)); + value = Convert<uint64_t>(GetArg64(args, 2)); ret = SetHardwareBreakPoint64(system, name, flags, value); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetDebugThreadParam64(Core::System& system) { +static void SvcWrap_GetDebugThreadParam64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_64{}; @@ -3607,18 +3607,18 @@ static void SvcWrap_GetDebugThreadParam64(Core::System& system) { uint64_t thread_id{}; DebugThreadParam param{}; - debug_handle = Convert<Handle>(GetReg64(system, 2)); - thread_id = Convert<uint64_t>(GetReg64(system, 3)); - param = Convert<DebugThreadParam>(GetReg64(system, 4)); + debug_handle = Convert<Handle>(GetArg64(args, 2)); + thread_id = Convert<uint64_t>(GetArg64(args, 3)); + param = Convert<DebugThreadParam>(GetArg64(args, 4)); ret = GetDebugThreadParam64(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_64)); - SetReg64(system, 2, Convert<uint64_t>(out_32)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_64)); + SetArg64(args, 2, Convert<uint64_t>(out_32)); } -static void SvcWrap_GetSystemInfo64(Core::System& system) { +static void SvcWrap_GetSystemInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -3626,17 +3626,17 @@ static void SvcWrap_GetSystemInfo64(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<SystemInfoType>(GetReg64(system, 1)); - handle = Convert<Handle>(GetReg64(system, 2)); - info_subtype = Convert<uint64_t>(GetReg64(system, 3)); + info_type = Convert<SystemInfoType>(GetArg64(args, 1)); + handle = Convert<Handle>(GetArg64(args, 2)); + info_subtype = Convert<uint64_t>(GetArg64(args, 3)); ret = GetSystemInfo64(system, std::addressof(out), info_type, handle, info_subtype); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out)); } -static void SvcWrap_CreatePort64(Core::System& system) { +static void SvcWrap_CreatePort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; @@ -3645,48 +3645,48 @@ static void SvcWrap_CreatePort64(Core::System& system) { bool is_light{}; uint64_t name{}; - max_sessions = Convert<int32_t>(GetReg64(system, 2)); - is_light = Convert<bool>(GetReg64(system, 3)); - name = Convert<uint64_t>(GetReg64(system, 4)); + max_sessions = Convert<int32_t>(GetArg64(args, 2)); + is_light = Convert<bool>(GetArg64(args, 3)); + name = Convert<uint64_t>(GetArg64(args, 4)); ret = CreatePort64(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_server_handle)); - SetReg64(system, 2, Convert<uint64_t>(out_client_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_server_handle)); + SetArg64(args, 2, Convert<uint64_t>(out_client_handle)); } -static void SvcWrap_ManageNamedPort64(Core::System& system) { +static void SvcWrap_ManageNamedPort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; uint64_t name{}; int32_t max_sessions{}; - name = Convert<uint64_t>(GetReg64(system, 1)); - max_sessions = Convert<int32_t>(GetReg64(system, 2)); + name = Convert<uint64_t>(GetArg64(args, 1)); + max_sessions = Convert<int32_t>(GetArg64(args, 2)); ret = ManageNamedPort64(system, std::addressof(out_server_handle), name, max_sessions); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_server_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_server_handle)); } -static void SvcWrap_ConnectToPort64(Core::System& system) { +static void SvcWrap_ConnectToPort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg64(system, 1)); + port = Convert<Handle>(GetArg64(args, 1)); ret = ConnectToPort64(system, std::addressof(out_handle), port); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) { +static void SvcWrap_SetProcessMemoryPermission64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3694,17 +3694,17 @@ static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - perm = Convert<MemoryPermission>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = SetProcessMemoryPermission64(system, process_handle, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapProcessMemory64(Core::System& system) { +static void SvcWrap_MapProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; @@ -3712,17 +3712,17 @@ static void SvcWrap_MapProcessMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = MapProcessMemory64(system, dst_address, process_handle, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapProcessMemory64(Core::System& system) { +static void SvcWrap_UnmapProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; @@ -3730,17 +3730,17 @@ static void SvcWrap_UnmapProcessMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = UnmapProcessMemory64(system, dst_address, process_handle, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_QueryProcessMemory64(Core::System& system) { +static void SvcWrap_QueryProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -3748,17 +3748,17 @@ static void SvcWrap_QueryProcessMemory64(Core::System& system) { Handle process_handle{}; uint64_t address{}; - out_memory_info = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 2)); - address = Convert<uint64_t>(GetReg64(system, 3)); + out_memory_info = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 2)); + address = Convert<uint64_t>(GetArg64(args, 3)); ret = QueryProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_page_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_page_info)); } -static void SvcWrap_MapProcessCodeMemory64(Core::System& system) { +static void SvcWrap_MapProcessCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3766,17 +3766,17 @@ static void SvcWrap_MapProcessCodeMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - dst_address = Convert<uint64_t>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + dst_address = Convert<uint64_t>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = MapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) { +static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3784,17 +3784,17 @@ static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - dst_address = Convert<uint64_t>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + dst_address = Convert<uint64_t>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = UnmapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateProcess64(Core::System& system) { +static void SvcWrap_CreateProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -3802,17 +3802,17 @@ static void SvcWrap_CreateProcess64(Core::System& system) { uint64_t caps{}; int32_t num_caps{}; - parameters = Convert<uint64_t>(GetReg64(system, 1)); - caps = Convert<uint64_t>(GetReg64(system, 2)); - num_caps = Convert<int32_t>(GetReg64(system, 3)); + parameters = Convert<uint64_t>(GetArg64(args, 1)); + caps = Convert<uint64_t>(GetArg64(args, 2)); + num_caps = Convert<int32_t>(GetArg64(args, 3)); ret = CreateProcess64(system, std::addressof(out_handle), parameters, caps, num_caps); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_StartProcess64(Core::System& system) { +static void SvcWrap_StartProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3820,601 +3820,601 @@ static void SvcWrap_StartProcess64(Core::System& system) { int32_t core_id{}; uint64_t main_thread_stack_size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - priority = Convert<int32_t>(GetReg64(system, 1)); - core_id = Convert<int32_t>(GetReg64(system, 2)); - main_thread_stack_size = Convert<uint64_t>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + priority = Convert<int32_t>(GetArg64(args, 1)); + core_id = Convert<int32_t>(GetArg64(args, 2)); + main_thread_stack_size = Convert<uint64_t>(GetArg64(args, 3)); ret = StartProcess64(system, process_handle, priority, core_id, main_thread_stack_size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_TerminateProcess64(Core::System& system) { +static void SvcWrap_TerminateProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); + process_handle = Convert<Handle>(GetArg64(args, 0)); ret = TerminateProcess64(system, process_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetProcessInfo64(Core::System& system) { +static void SvcWrap_GetProcessInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_info{}; Handle process_handle{}; ProcessInfoType info_type{}; - process_handle = Convert<Handle>(GetReg64(system, 1)); - info_type = Convert<ProcessInfoType>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + info_type = Convert<ProcessInfoType>(GetArg64(args, 2)); ret = GetProcessInfo64(system, std::addressof(out_info), process_handle, info_type); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_info)); } -static void SvcWrap_CreateResourceLimit64(Core::System& system) { +static void SvcWrap_CreateResourceLimit64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; ret = CreateResourceLimit64(system, std::addressof(out_handle)); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system) { +static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle resource_limit_handle{}; LimitableResource which{}; int64_t limit_value{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 0)); - which = Convert<LimitableResource>(GetReg64(system, 1)); - limit_value = Convert<int64_t>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 0)); + which = Convert<LimitableResource>(GetArg64(args, 1)); + limit_value = Convert<int64_t>(GetArg64(args, 2)); ret = SetResourceLimitLimitValue64(system, resource_limit_handle, which, limit_value); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapInsecureMemory64(Core::System& system) { +static void SvcWrap_MapInsecureMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = MapInsecureMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapInsecureMemory64(Core::System& system) { +static void SvcWrap_UnmapInsecureMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = UnmapInsecureMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void Call32(Core::System& system, u32 imm) { +static void Call32(Core::System& system, u32 imm, std::span<uint64_t, 8> args) { switch (static_cast<SvcId>(imm)) { case SvcId::SetHeapSize: - return SvcWrap_SetHeapSize64From32(system); + return SvcWrap_SetHeapSize64From32(system, args); case SvcId::SetMemoryPermission: - return SvcWrap_SetMemoryPermission64From32(system); + return SvcWrap_SetMemoryPermission64From32(system, args); case SvcId::SetMemoryAttribute: - return SvcWrap_SetMemoryAttribute64From32(system); + return SvcWrap_SetMemoryAttribute64From32(system, args); case SvcId::MapMemory: - return SvcWrap_MapMemory64From32(system); + return SvcWrap_MapMemory64From32(system, args); case SvcId::UnmapMemory: - return SvcWrap_UnmapMemory64From32(system); + return SvcWrap_UnmapMemory64From32(system, args); case SvcId::QueryMemory: - return SvcWrap_QueryMemory64From32(system); + return SvcWrap_QueryMemory64From32(system, args); case SvcId::ExitProcess: - return SvcWrap_ExitProcess64From32(system); + return SvcWrap_ExitProcess64From32(system, args); case SvcId::CreateThread: - return SvcWrap_CreateThread64From32(system); + return SvcWrap_CreateThread64From32(system, args); case SvcId::StartThread: - return SvcWrap_StartThread64From32(system); + return SvcWrap_StartThread64From32(system, args); case SvcId::ExitThread: - return SvcWrap_ExitThread64From32(system); + return SvcWrap_ExitThread64From32(system, args); case SvcId::SleepThread: - return SvcWrap_SleepThread64From32(system); + return SvcWrap_SleepThread64From32(system, args); case SvcId::GetThreadPriority: - return SvcWrap_GetThreadPriority64From32(system); + return SvcWrap_GetThreadPriority64From32(system, args); case SvcId::SetThreadPriority: - return SvcWrap_SetThreadPriority64From32(system); + return SvcWrap_SetThreadPriority64From32(system, args); case SvcId::GetThreadCoreMask: - return SvcWrap_GetThreadCoreMask64From32(system); + return SvcWrap_GetThreadCoreMask64From32(system, args); case SvcId::SetThreadCoreMask: - return SvcWrap_SetThreadCoreMask64From32(system); + return SvcWrap_SetThreadCoreMask64From32(system, args); case SvcId::GetCurrentProcessorNumber: - return SvcWrap_GetCurrentProcessorNumber64From32(system); + return SvcWrap_GetCurrentProcessorNumber64From32(system, args); case SvcId::SignalEvent: - return SvcWrap_SignalEvent64From32(system); + return SvcWrap_SignalEvent64From32(system, args); case SvcId::ClearEvent: - return SvcWrap_ClearEvent64From32(system); + return SvcWrap_ClearEvent64From32(system, args); case SvcId::MapSharedMemory: - return SvcWrap_MapSharedMemory64From32(system); + return SvcWrap_MapSharedMemory64From32(system, args); case SvcId::UnmapSharedMemory: - return SvcWrap_UnmapSharedMemory64From32(system); + return SvcWrap_UnmapSharedMemory64From32(system, args); case SvcId::CreateTransferMemory: - return SvcWrap_CreateTransferMemory64From32(system); + return SvcWrap_CreateTransferMemory64From32(system, args); case SvcId::CloseHandle: - return SvcWrap_CloseHandle64From32(system); + return SvcWrap_CloseHandle64From32(system, args); case SvcId::ResetSignal: - return SvcWrap_ResetSignal64From32(system); + return SvcWrap_ResetSignal64From32(system, args); case SvcId::WaitSynchronization: - return SvcWrap_WaitSynchronization64From32(system); + return SvcWrap_WaitSynchronization64From32(system, args); case SvcId::CancelSynchronization: - return SvcWrap_CancelSynchronization64From32(system); + return SvcWrap_CancelSynchronization64From32(system, args); case SvcId::ArbitrateLock: - return SvcWrap_ArbitrateLock64From32(system); + return SvcWrap_ArbitrateLock64From32(system, args); case SvcId::ArbitrateUnlock: - return SvcWrap_ArbitrateUnlock64From32(system); + return SvcWrap_ArbitrateUnlock64From32(system, args); case SvcId::WaitProcessWideKeyAtomic: - return SvcWrap_WaitProcessWideKeyAtomic64From32(system); + return SvcWrap_WaitProcessWideKeyAtomic64From32(system, args); case SvcId::SignalProcessWideKey: - return SvcWrap_SignalProcessWideKey64From32(system); + return SvcWrap_SignalProcessWideKey64From32(system, args); case SvcId::GetSystemTick: - return SvcWrap_GetSystemTick64From32(system); + return SvcWrap_GetSystemTick64From32(system, args); case SvcId::ConnectToNamedPort: - return SvcWrap_ConnectToNamedPort64From32(system); + return SvcWrap_ConnectToNamedPort64From32(system, args); case SvcId::SendSyncRequestLight: - return SvcWrap_SendSyncRequestLight64From32(system); + return SvcWrap_SendSyncRequestLight64From32(system, args); case SvcId::SendSyncRequest: - return SvcWrap_SendSyncRequest64From32(system); + return SvcWrap_SendSyncRequest64From32(system, args); case SvcId::SendSyncRequestWithUserBuffer: - return SvcWrap_SendSyncRequestWithUserBuffer64From32(system); + return SvcWrap_SendSyncRequestWithUserBuffer64From32(system, args); case SvcId::SendAsyncRequestWithUserBuffer: - return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system); + return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system, args); case SvcId::GetProcessId: - return SvcWrap_GetProcessId64From32(system); + return SvcWrap_GetProcessId64From32(system, args); case SvcId::GetThreadId: - return SvcWrap_GetThreadId64From32(system); + return SvcWrap_GetThreadId64From32(system, args); case SvcId::Break: - return SvcWrap_Break64From32(system); + return SvcWrap_Break64From32(system, args); case SvcId::OutputDebugString: - return SvcWrap_OutputDebugString64From32(system); + return SvcWrap_OutputDebugString64From32(system, args); case SvcId::ReturnFromException: - return SvcWrap_ReturnFromException64From32(system); + return SvcWrap_ReturnFromException64From32(system, args); case SvcId::GetInfo: - return SvcWrap_GetInfo64From32(system); + return SvcWrap_GetInfo64From32(system, args); case SvcId::FlushEntireDataCache: - return SvcWrap_FlushEntireDataCache64From32(system); + return SvcWrap_FlushEntireDataCache64From32(system, args); case SvcId::FlushDataCache: - return SvcWrap_FlushDataCache64From32(system); + return SvcWrap_FlushDataCache64From32(system, args); case SvcId::MapPhysicalMemory: - return SvcWrap_MapPhysicalMemory64From32(system); + return SvcWrap_MapPhysicalMemory64From32(system, args); case SvcId::UnmapPhysicalMemory: - return SvcWrap_UnmapPhysicalMemory64From32(system); + return SvcWrap_UnmapPhysicalMemory64From32(system, args); case SvcId::GetDebugFutureThreadInfo: - return SvcWrap_GetDebugFutureThreadInfo64From32(system); + return SvcWrap_GetDebugFutureThreadInfo64From32(system, args); case SvcId::GetLastThreadInfo: - return SvcWrap_GetLastThreadInfo64From32(system); + return SvcWrap_GetLastThreadInfo64From32(system, args); case SvcId::GetResourceLimitLimitValue: - return SvcWrap_GetResourceLimitLimitValue64From32(system); + return SvcWrap_GetResourceLimitLimitValue64From32(system, args); case SvcId::GetResourceLimitCurrentValue: - return SvcWrap_GetResourceLimitCurrentValue64From32(system); + return SvcWrap_GetResourceLimitCurrentValue64From32(system, args); case SvcId::SetThreadActivity: - return SvcWrap_SetThreadActivity64From32(system); + return SvcWrap_SetThreadActivity64From32(system, args); case SvcId::GetThreadContext3: - return SvcWrap_GetThreadContext364From32(system); + return SvcWrap_GetThreadContext364From32(system, args); case SvcId::WaitForAddress: - return SvcWrap_WaitForAddress64From32(system); + return SvcWrap_WaitForAddress64From32(system, args); case SvcId::SignalToAddress: - return SvcWrap_SignalToAddress64From32(system); + return SvcWrap_SignalToAddress64From32(system, args); case SvcId::SynchronizePreemptionState: - return SvcWrap_SynchronizePreemptionState64From32(system); + return SvcWrap_SynchronizePreemptionState64From32(system, args); case SvcId::GetResourceLimitPeakValue: - return SvcWrap_GetResourceLimitPeakValue64From32(system); + return SvcWrap_GetResourceLimitPeakValue64From32(system, args); case SvcId::CreateIoPool: - return SvcWrap_CreateIoPool64From32(system); + return SvcWrap_CreateIoPool64From32(system, args); case SvcId::CreateIoRegion: - return SvcWrap_CreateIoRegion64From32(system); + return SvcWrap_CreateIoRegion64From32(system, args); case SvcId::KernelDebug: - return SvcWrap_KernelDebug64From32(system); + return SvcWrap_KernelDebug64From32(system, args); case SvcId::ChangeKernelTraceState: - return SvcWrap_ChangeKernelTraceState64From32(system); + return SvcWrap_ChangeKernelTraceState64From32(system, args); case SvcId::CreateSession: - return SvcWrap_CreateSession64From32(system); + return SvcWrap_CreateSession64From32(system, args); case SvcId::AcceptSession: - return SvcWrap_AcceptSession64From32(system); + return SvcWrap_AcceptSession64From32(system, args); case SvcId::ReplyAndReceiveLight: - return SvcWrap_ReplyAndReceiveLight64From32(system); + return SvcWrap_ReplyAndReceiveLight64From32(system, args); case SvcId::ReplyAndReceive: - return SvcWrap_ReplyAndReceive64From32(system); + return SvcWrap_ReplyAndReceive64From32(system, args); case SvcId::ReplyAndReceiveWithUserBuffer: - return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system); + return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system, args); case SvcId::CreateEvent: - return SvcWrap_CreateEvent64From32(system); + return SvcWrap_CreateEvent64From32(system, args); case SvcId::MapIoRegion: - return SvcWrap_MapIoRegion64From32(system); + return SvcWrap_MapIoRegion64From32(system, args); case SvcId::UnmapIoRegion: - return SvcWrap_UnmapIoRegion64From32(system); + return SvcWrap_UnmapIoRegion64From32(system, args); case SvcId::MapPhysicalMemoryUnsafe: - return SvcWrap_MapPhysicalMemoryUnsafe64From32(system); + return SvcWrap_MapPhysicalMemoryUnsafe64From32(system, args); case SvcId::UnmapPhysicalMemoryUnsafe: - return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system); + return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system, args); case SvcId::SetUnsafeLimit: - return SvcWrap_SetUnsafeLimit64From32(system); + return SvcWrap_SetUnsafeLimit64From32(system, args); case SvcId::CreateCodeMemory: - return SvcWrap_CreateCodeMemory64From32(system); + return SvcWrap_CreateCodeMemory64From32(system, args); case SvcId::ControlCodeMemory: - return SvcWrap_ControlCodeMemory64From32(system); + return SvcWrap_ControlCodeMemory64From32(system, args); case SvcId::SleepSystem: - return SvcWrap_SleepSystem64From32(system); + return SvcWrap_SleepSystem64From32(system, args); case SvcId::ReadWriteRegister: - return SvcWrap_ReadWriteRegister64From32(system); + return SvcWrap_ReadWriteRegister64From32(system, args); case SvcId::SetProcessActivity: - return SvcWrap_SetProcessActivity64From32(system); + return SvcWrap_SetProcessActivity64From32(system, args); case SvcId::CreateSharedMemory: - return SvcWrap_CreateSharedMemory64From32(system); + return SvcWrap_CreateSharedMemory64From32(system, args); case SvcId::MapTransferMemory: - return SvcWrap_MapTransferMemory64From32(system); + return SvcWrap_MapTransferMemory64From32(system, args); case SvcId::UnmapTransferMemory: - return SvcWrap_UnmapTransferMemory64From32(system); + return SvcWrap_UnmapTransferMemory64From32(system, args); case SvcId::CreateInterruptEvent: - return SvcWrap_CreateInterruptEvent64From32(system); + return SvcWrap_CreateInterruptEvent64From32(system, args); case SvcId::QueryPhysicalAddress: - return SvcWrap_QueryPhysicalAddress64From32(system); + return SvcWrap_QueryPhysicalAddress64From32(system, args); case SvcId::QueryIoMapping: - return SvcWrap_QueryIoMapping64From32(system); + return SvcWrap_QueryIoMapping64From32(system, args); case SvcId::CreateDeviceAddressSpace: - return SvcWrap_CreateDeviceAddressSpace64From32(system); + return SvcWrap_CreateDeviceAddressSpace64From32(system, args); case SvcId::AttachDeviceAddressSpace: - return SvcWrap_AttachDeviceAddressSpace64From32(system); + return SvcWrap_AttachDeviceAddressSpace64From32(system, args); case SvcId::DetachDeviceAddressSpace: - return SvcWrap_DetachDeviceAddressSpace64From32(system); + return SvcWrap_DetachDeviceAddressSpace64From32(system, args); case SvcId::MapDeviceAddressSpaceByForce: - return SvcWrap_MapDeviceAddressSpaceByForce64From32(system); + return SvcWrap_MapDeviceAddressSpaceByForce64From32(system, args); case SvcId::MapDeviceAddressSpaceAligned: - return SvcWrap_MapDeviceAddressSpaceAligned64From32(system); + return SvcWrap_MapDeviceAddressSpaceAligned64From32(system, args); case SvcId::UnmapDeviceAddressSpace: - return SvcWrap_UnmapDeviceAddressSpace64From32(system); + return SvcWrap_UnmapDeviceAddressSpace64From32(system, args); case SvcId::InvalidateProcessDataCache: - return SvcWrap_InvalidateProcessDataCache64From32(system); + return SvcWrap_InvalidateProcessDataCache64From32(system, args); case SvcId::StoreProcessDataCache: - return SvcWrap_StoreProcessDataCache64From32(system); + return SvcWrap_StoreProcessDataCache64From32(system, args); case SvcId::FlushProcessDataCache: - return SvcWrap_FlushProcessDataCache64From32(system); + return SvcWrap_FlushProcessDataCache64From32(system, args); case SvcId::DebugActiveProcess: - return SvcWrap_DebugActiveProcess64From32(system); + return SvcWrap_DebugActiveProcess64From32(system, args); case SvcId::BreakDebugProcess: - return SvcWrap_BreakDebugProcess64From32(system); + return SvcWrap_BreakDebugProcess64From32(system, args); case SvcId::TerminateDebugProcess: - return SvcWrap_TerminateDebugProcess64From32(system); + return SvcWrap_TerminateDebugProcess64From32(system, args); case SvcId::GetDebugEvent: - return SvcWrap_GetDebugEvent64From32(system); + return SvcWrap_GetDebugEvent64From32(system, args); case SvcId::ContinueDebugEvent: - return SvcWrap_ContinueDebugEvent64From32(system); + return SvcWrap_ContinueDebugEvent64From32(system, args); case SvcId::GetProcessList: - return SvcWrap_GetProcessList64From32(system); + return SvcWrap_GetProcessList64From32(system, args); case SvcId::GetThreadList: - return SvcWrap_GetThreadList64From32(system); + return SvcWrap_GetThreadList64From32(system, args); case SvcId::GetDebugThreadContext: - return SvcWrap_GetDebugThreadContext64From32(system); + return SvcWrap_GetDebugThreadContext64From32(system, args); case SvcId::SetDebugThreadContext: - return SvcWrap_SetDebugThreadContext64From32(system); + return SvcWrap_SetDebugThreadContext64From32(system, args); case SvcId::QueryDebugProcessMemory: - return SvcWrap_QueryDebugProcessMemory64From32(system); + return SvcWrap_QueryDebugProcessMemory64From32(system, args); case SvcId::ReadDebugProcessMemory: - return SvcWrap_ReadDebugProcessMemory64From32(system); + return SvcWrap_ReadDebugProcessMemory64From32(system, args); case SvcId::WriteDebugProcessMemory: - return SvcWrap_WriteDebugProcessMemory64From32(system); + return SvcWrap_WriteDebugProcessMemory64From32(system, args); case SvcId::SetHardwareBreakPoint: - return SvcWrap_SetHardwareBreakPoint64From32(system); + return SvcWrap_SetHardwareBreakPoint64From32(system, args); case SvcId::GetDebugThreadParam: - return SvcWrap_GetDebugThreadParam64From32(system); + return SvcWrap_GetDebugThreadParam64From32(system, args); case SvcId::GetSystemInfo: - return SvcWrap_GetSystemInfo64From32(system); + return SvcWrap_GetSystemInfo64From32(system, args); case SvcId::CreatePort: - return SvcWrap_CreatePort64From32(system); + return SvcWrap_CreatePort64From32(system, args); case SvcId::ManageNamedPort: - return SvcWrap_ManageNamedPort64From32(system); + return SvcWrap_ManageNamedPort64From32(system, args); case SvcId::ConnectToPort: - return SvcWrap_ConnectToPort64From32(system); + return SvcWrap_ConnectToPort64From32(system, args); case SvcId::SetProcessMemoryPermission: - return SvcWrap_SetProcessMemoryPermission64From32(system); + return SvcWrap_SetProcessMemoryPermission64From32(system, args); case SvcId::MapProcessMemory: - return SvcWrap_MapProcessMemory64From32(system); + return SvcWrap_MapProcessMemory64From32(system, args); case SvcId::UnmapProcessMemory: - return SvcWrap_UnmapProcessMemory64From32(system); + return SvcWrap_UnmapProcessMemory64From32(system, args); case SvcId::QueryProcessMemory: - return SvcWrap_QueryProcessMemory64From32(system); + return SvcWrap_QueryProcessMemory64From32(system, args); case SvcId::MapProcessCodeMemory: - return SvcWrap_MapProcessCodeMemory64From32(system); + return SvcWrap_MapProcessCodeMemory64From32(system, args); case SvcId::UnmapProcessCodeMemory: - return SvcWrap_UnmapProcessCodeMemory64From32(system); + return SvcWrap_UnmapProcessCodeMemory64From32(system, args); case SvcId::CreateProcess: - return SvcWrap_CreateProcess64From32(system); + return SvcWrap_CreateProcess64From32(system, args); case SvcId::StartProcess: - return SvcWrap_StartProcess64From32(system); + return SvcWrap_StartProcess64From32(system, args); case SvcId::TerminateProcess: - return SvcWrap_TerminateProcess64From32(system); + return SvcWrap_TerminateProcess64From32(system, args); case SvcId::GetProcessInfo: - return SvcWrap_GetProcessInfo64From32(system); + return SvcWrap_GetProcessInfo64From32(system, args); case SvcId::CreateResourceLimit: - return SvcWrap_CreateResourceLimit64From32(system); + return SvcWrap_CreateResourceLimit64From32(system, args); case SvcId::SetResourceLimitLimitValue: - return SvcWrap_SetResourceLimitLimitValue64From32(system); + return SvcWrap_SetResourceLimitLimitValue64From32(system, args); case SvcId::CallSecureMonitor: - return SvcWrap_CallSecureMonitor64From32(system); + return SvcWrap_CallSecureMonitor64From32(system, args); case SvcId::MapInsecureMemory: - return SvcWrap_MapInsecureMemory64From32(system); + return SvcWrap_MapInsecureMemory64From32(system, args); case SvcId::UnmapInsecureMemory: - return SvcWrap_UnmapInsecureMemory64From32(system); + return SvcWrap_UnmapInsecureMemory64From32(system, args); default: LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm); break; } } -static void Call64(Core::System& system, u32 imm) { +static void Call64(Core::System& system, u32 imm, std::span<uint64_t, 8> args) { switch (static_cast<SvcId>(imm)) { case SvcId::SetHeapSize: - return SvcWrap_SetHeapSize64(system); + return SvcWrap_SetHeapSize64(system, args); case SvcId::SetMemoryPermission: - return SvcWrap_SetMemoryPermission64(system); + return SvcWrap_SetMemoryPermission64(system, args); case SvcId::SetMemoryAttribute: - return SvcWrap_SetMemoryAttribute64(system); + return SvcWrap_SetMemoryAttribute64(system, args); case SvcId::MapMemory: - return SvcWrap_MapMemory64(system); + return SvcWrap_MapMemory64(system, args); case SvcId::UnmapMemory: - return SvcWrap_UnmapMemory64(system); + return SvcWrap_UnmapMemory64(system, args); case SvcId::QueryMemory: - return SvcWrap_QueryMemory64(system); + return SvcWrap_QueryMemory64(system, args); case SvcId::ExitProcess: - return SvcWrap_ExitProcess64(system); + return SvcWrap_ExitProcess64(system, args); case SvcId::CreateThread: - return SvcWrap_CreateThread64(system); + return SvcWrap_CreateThread64(system, args); case SvcId::StartThread: - return SvcWrap_StartThread64(system); + return SvcWrap_StartThread64(system, args); case SvcId::ExitThread: - return SvcWrap_ExitThread64(system); + return SvcWrap_ExitThread64(system, args); case SvcId::SleepThread: - return SvcWrap_SleepThread64(system); + return SvcWrap_SleepThread64(system, args); case SvcId::GetThreadPriority: - return SvcWrap_GetThreadPriority64(system); + return SvcWrap_GetThreadPriority64(system, args); case SvcId::SetThreadPriority: - return SvcWrap_SetThreadPriority64(system); + return SvcWrap_SetThreadPriority64(system, args); case SvcId::GetThreadCoreMask: - return SvcWrap_GetThreadCoreMask64(system); + return SvcWrap_GetThreadCoreMask64(system, args); case SvcId::SetThreadCoreMask: - return SvcWrap_SetThreadCoreMask64(system); + return SvcWrap_SetThreadCoreMask64(system, args); case SvcId::GetCurrentProcessorNumber: - return SvcWrap_GetCurrentProcessorNumber64(system); + return SvcWrap_GetCurrentProcessorNumber64(system, args); case SvcId::SignalEvent: - return SvcWrap_SignalEvent64(system); + return SvcWrap_SignalEvent64(system, args); case SvcId::ClearEvent: - return SvcWrap_ClearEvent64(system); + return SvcWrap_ClearEvent64(system, args); case SvcId::MapSharedMemory: - return SvcWrap_MapSharedMemory64(system); + return SvcWrap_MapSharedMemory64(system, args); case SvcId::UnmapSharedMemory: - return SvcWrap_UnmapSharedMemory64(system); + return SvcWrap_UnmapSharedMemory64(system, args); case SvcId::CreateTransferMemory: - return SvcWrap_CreateTransferMemory64(system); + return SvcWrap_CreateTransferMemory64(system, args); case SvcId::CloseHandle: - return SvcWrap_CloseHandle64(system); + return SvcWrap_CloseHandle64(system, args); case SvcId::ResetSignal: - return SvcWrap_ResetSignal64(system); + return SvcWrap_ResetSignal64(system, args); case SvcId::WaitSynchronization: - return SvcWrap_WaitSynchronization64(system); + return SvcWrap_WaitSynchronization64(system, args); case SvcId::CancelSynchronization: - return SvcWrap_CancelSynchronization64(system); + return SvcWrap_CancelSynchronization64(system, args); case SvcId::ArbitrateLock: - return SvcWrap_ArbitrateLock64(system); + return SvcWrap_ArbitrateLock64(system, args); case SvcId::ArbitrateUnlock: - return SvcWrap_ArbitrateUnlock64(system); + return SvcWrap_ArbitrateUnlock64(system, args); case SvcId::WaitProcessWideKeyAtomic: - return SvcWrap_WaitProcessWideKeyAtomic64(system); + return SvcWrap_WaitProcessWideKeyAtomic64(system, args); case SvcId::SignalProcessWideKey: - return SvcWrap_SignalProcessWideKey64(system); + return SvcWrap_SignalProcessWideKey64(system, args); case SvcId::GetSystemTick: - return SvcWrap_GetSystemTick64(system); + return SvcWrap_GetSystemTick64(system, args); case SvcId::ConnectToNamedPort: - return SvcWrap_ConnectToNamedPort64(system); + return SvcWrap_ConnectToNamedPort64(system, args); case SvcId::SendSyncRequestLight: - return SvcWrap_SendSyncRequestLight64(system); + return SvcWrap_SendSyncRequestLight64(system, args); case SvcId::SendSyncRequest: - return SvcWrap_SendSyncRequest64(system); + return SvcWrap_SendSyncRequest64(system, args); case SvcId::SendSyncRequestWithUserBuffer: - return SvcWrap_SendSyncRequestWithUserBuffer64(system); + return SvcWrap_SendSyncRequestWithUserBuffer64(system, args); case SvcId::SendAsyncRequestWithUserBuffer: - return SvcWrap_SendAsyncRequestWithUserBuffer64(system); + return SvcWrap_SendAsyncRequestWithUserBuffer64(system, args); case SvcId::GetProcessId: - return SvcWrap_GetProcessId64(system); + return SvcWrap_GetProcessId64(system, args); case SvcId::GetThreadId: - return SvcWrap_GetThreadId64(system); + return SvcWrap_GetThreadId64(system, args); case SvcId::Break: - return SvcWrap_Break64(system); + return SvcWrap_Break64(system, args); case SvcId::OutputDebugString: - return SvcWrap_OutputDebugString64(system); + return SvcWrap_OutputDebugString64(system, args); case SvcId::ReturnFromException: - return SvcWrap_ReturnFromException64(system); + return SvcWrap_ReturnFromException64(system, args); case SvcId::GetInfo: - return SvcWrap_GetInfo64(system); + return SvcWrap_GetInfo64(system, args); case SvcId::FlushEntireDataCache: - return SvcWrap_FlushEntireDataCache64(system); + return SvcWrap_FlushEntireDataCache64(system, args); case SvcId::FlushDataCache: - return SvcWrap_FlushDataCache64(system); + return SvcWrap_FlushDataCache64(system, args); case SvcId::MapPhysicalMemory: - return SvcWrap_MapPhysicalMemory64(system); + return SvcWrap_MapPhysicalMemory64(system, args); case SvcId::UnmapPhysicalMemory: - return SvcWrap_UnmapPhysicalMemory64(system); + return SvcWrap_UnmapPhysicalMemory64(system, args); case SvcId::GetDebugFutureThreadInfo: - return SvcWrap_GetDebugFutureThreadInfo64(system); + return SvcWrap_GetDebugFutureThreadInfo64(system, args); case SvcId::GetLastThreadInfo: - return SvcWrap_GetLastThreadInfo64(system); + return SvcWrap_GetLastThreadInfo64(system, args); case SvcId::GetResourceLimitLimitValue: - return SvcWrap_GetResourceLimitLimitValue64(system); + return SvcWrap_GetResourceLimitLimitValue64(system, args); case SvcId::GetResourceLimitCurrentValue: - return SvcWrap_GetResourceLimitCurrentValue64(system); + return SvcWrap_GetResourceLimitCurrentValue64(system, args); case SvcId::SetThreadActivity: - return SvcWrap_SetThreadActivity64(system); + return SvcWrap_SetThreadActivity64(system, args); case SvcId::GetThreadContext3: - return SvcWrap_GetThreadContext364(system); + return SvcWrap_GetThreadContext364(system, args); case SvcId::WaitForAddress: - return SvcWrap_WaitForAddress64(system); + return SvcWrap_WaitForAddress64(system, args); case SvcId::SignalToAddress: - return SvcWrap_SignalToAddress64(system); + return SvcWrap_SignalToAddress64(system, args); case SvcId::SynchronizePreemptionState: - return SvcWrap_SynchronizePreemptionState64(system); + return SvcWrap_SynchronizePreemptionState64(system, args); case SvcId::GetResourceLimitPeakValue: - return SvcWrap_GetResourceLimitPeakValue64(system); + return SvcWrap_GetResourceLimitPeakValue64(system, args); case SvcId::CreateIoPool: - return SvcWrap_CreateIoPool64(system); + return SvcWrap_CreateIoPool64(system, args); case SvcId::CreateIoRegion: - return SvcWrap_CreateIoRegion64(system); + return SvcWrap_CreateIoRegion64(system, args); case SvcId::KernelDebug: - return SvcWrap_KernelDebug64(system); + return SvcWrap_KernelDebug64(system, args); case SvcId::ChangeKernelTraceState: - return SvcWrap_ChangeKernelTraceState64(system); + return SvcWrap_ChangeKernelTraceState64(system, args); case SvcId::CreateSession: - return SvcWrap_CreateSession64(system); + return SvcWrap_CreateSession64(system, args); case SvcId::AcceptSession: - return SvcWrap_AcceptSession64(system); + return SvcWrap_AcceptSession64(system, args); case SvcId::ReplyAndReceiveLight: - return SvcWrap_ReplyAndReceiveLight64(system); + return SvcWrap_ReplyAndReceiveLight64(system, args); case SvcId::ReplyAndReceive: - return SvcWrap_ReplyAndReceive64(system); + return SvcWrap_ReplyAndReceive64(system, args); case SvcId::ReplyAndReceiveWithUserBuffer: - return SvcWrap_ReplyAndReceiveWithUserBuffer64(system); + return SvcWrap_ReplyAndReceiveWithUserBuffer64(system, args); case SvcId::CreateEvent: - return SvcWrap_CreateEvent64(system); + return SvcWrap_CreateEvent64(system, args); case SvcId::MapIoRegion: - return SvcWrap_MapIoRegion64(system); + return SvcWrap_MapIoRegion64(system, args); case SvcId::UnmapIoRegion: - return SvcWrap_UnmapIoRegion64(system); + return SvcWrap_UnmapIoRegion64(system, args); case SvcId::MapPhysicalMemoryUnsafe: - return SvcWrap_MapPhysicalMemoryUnsafe64(system); + return SvcWrap_MapPhysicalMemoryUnsafe64(system, args); case SvcId::UnmapPhysicalMemoryUnsafe: - return SvcWrap_UnmapPhysicalMemoryUnsafe64(system); + return SvcWrap_UnmapPhysicalMemoryUnsafe64(system, args); case SvcId::SetUnsafeLimit: - return SvcWrap_SetUnsafeLimit64(system); + return SvcWrap_SetUnsafeLimit64(system, args); case SvcId::CreateCodeMemory: - return SvcWrap_CreateCodeMemory64(system); + return SvcWrap_CreateCodeMemory64(system, args); case SvcId::ControlCodeMemory: - return SvcWrap_ControlCodeMemory64(system); + return SvcWrap_ControlCodeMemory64(system, args); case SvcId::SleepSystem: - return SvcWrap_SleepSystem64(system); + return SvcWrap_SleepSystem64(system, args); case SvcId::ReadWriteRegister: - return SvcWrap_ReadWriteRegister64(system); + return SvcWrap_ReadWriteRegister64(system, args); case SvcId::SetProcessActivity: - return SvcWrap_SetProcessActivity64(system); + return SvcWrap_SetProcessActivity64(system, args); case SvcId::CreateSharedMemory: - return SvcWrap_CreateSharedMemory64(system); + return SvcWrap_CreateSharedMemory64(system, args); case SvcId::MapTransferMemory: - return SvcWrap_MapTransferMemory64(system); + return SvcWrap_MapTransferMemory64(system, args); case SvcId::UnmapTransferMemory: - return SvcWrap_UnmapTransferMemory64(system); + return SvcWrap_UnmapTransferMemory64(system, args); case SvcId::CreateInterruptEvent: - return SvcWrap_CreateInterruptEvent64(system); + return SvcWrap_CreateInterruptEvent64(system, args); case SvcId::QueryPhysicalAddress: - return SvcWrap_QueryPhysicalAddress64(system); + return SvcWrap_QueryPhysicalAddress64(system, args); case SvcId::QueryIoMapping: - return SvcWrap_QueryIoMapping64(system); + return SvcWrap_QueryIoMapping64(system, args); case SvcId::CreateDeviceAddressSpace: - return SvcWrap_CreateDeviceAddressSpace64(system); + return SvcWrap_CreateDeviceAddressSpace64(system, args); case SvcId::AttachDeviceAddressSpace: - return SvcWrap_AttachDeviceAddressSpace64(system); + return SvcWrap_AttachDeviceAddressSpace64(system, args); case SvcId::DetachDeviceAddressSpace: - return SvcWrap_DetachDeviceAddressSpace64(system); + return SvcWrap_DetachDeviceAddressSpace64(system, args); case SvcId::MapDeviceAddressSpaceByForce: - return SvcWrap_MapDeviceAddressSpaceByForce64(system); + return SvcWrap_MapDeviceAddressSpaceByForce64(system, args); case SvcId::MapDeviceAddressSpaceAligned: - return SvcWrap_MapDeviceAddressSpaceAligned64(system); + return SvcWrap_MapDeviceAddressSpaceAligned64(system, args); case SvcId::UnmapDeviceAddressSpace: - return SvcWrap_UnmapDeviceAddressSpace64(system); + return SvcWrap_UnmapDeviceAddressSpace64(system, args); case SvcId::InvalidateProcessDataCache: - return SvcWrap_InvalidateProcessDataCache64(system); + return SvcWrap_InvalidateProcessDataCache64(system, args); case SvcId::StoreProcessDataCache: - return SvcWrap_StoreProcessDataCache64(system); + return SvcWrap_StoreProcessDataCache64(system, args); case SvcId::FlushProcessDataCache: - return SvcWrap_FlushProcessDataCache64(system); + return SvcWrap_FlushProcessDataCache64(system, args); case SvcId::DebugActiveProcess: - return SvcWrap_DebugActiveProcess64(system); + return SvcWrap_DebugActiveProcess64(system, args); case SvcId::BreakDebugProcess: - return SvcWrap_BreakDebugProcess64(system); + return SvcWrap_BreakDebugProcess64(system, args); case SvcId::TerminateDebugProcess: - return SvcWrap_TerminateDebugProcess64(system); + return SvcWrap_TerminateDebugProcess64(system, args); case SvcId::GetDebugEvent: - return SvcWrap_GetDebugEvent64(system); + return SvcWrap_GetDebugEvent64(system, args); case SvcId::ContinueDebugEvent: - return SvcWrap_ContinueDebugEvent64(system); + return SvcWrap_ContinueDebugEvent64(system, args); case SvcId::GetProcessList: - return SvcWrap_GetProcessList64(system); + return SvcWrap_GetProcessList64(system, args); case SvcId::GetThreadList: - return SvcWrap_GetThreadList64(system); + return SvcWrap_GetThreadList64(system, args); case SvcId::GetDebugThreadContext: - return SvcWrap_GetDebugThreadContext64(system); + return SvcWrap_GetDebugThreadContext64(system, args); case SvcId::SetDebugThreadContext: - return SvcWrap_SetDebugThreadContext64(system); + return SvcWrap_SetDebugThreadContext64(system, args); case SvcId::QueryDebugProcessMemory: - return SvcWrap_QueryDebugProcessMemory64(system); + return SvcWrap_QueryDebugProcessMemory64(system, args); case SvcId::ReadDebugProcessMemory: - return SvcWrap_ReadDebugProcessMemory64(system); + return SvcWrap_ReadDebugProcessMemory64(system, args); case SvcId::WriteDebugProcessMemory: - return SvcWrap_WriteDebugProcessMemory64(system); + return SvcWrap_WriteDebugProcessMemory64(system, args); case SvcId::SetHardwareBreakPoint: - return SvcWrap_SetHardwareBreakPoint64(system); + return SvcWrap_SetHardwareBreakPoint64(system, args); case SvcId::GetDebugThreadParam: - return SvcWrap_GetDebugThreadParam64(system); + return SvcWrap_GetDebugThreadParam64(system, args); case SvcId::GetSystemInfo: - return SvcWrap_GetSystemInfo64(system); + return SvcWrap_GetSystemInfo64(system, args); case SvcId::CreatePort: - return SvcWrap_CreatePort64(system); + return SvcWrap_CreatePort64(system, args); case SvcId::ManageNamedPort: - return SvcWrap_ManageNamedPort64(system); + return SvcWrap_ManageNamedPort64(system, args); case SvcId::ConnectToPort: - return SvcWrap_ConnectToPort64(system); + return SvcWrap_ConnectToPort64(system, args); case SvcId::SetProcessMemoryPermission: - return SvcWrap_SetProcessMemoryPermission64(system); + return SvcWrap_SetProcessMemoryPermission64(system, args); case SvcId::MapProcessMemory: - return SvcWrap_MapProcessMemory64(system); + return SvcWrap_MapProcessMemory64(system, args); case SvcId::UnmapProcessMemory: - return SvcWrap_UnmapProcessMemory64(system); + return SvcWrap_UnmapProcessMemory64(system, args); case SvcId::QueryProcessMemory: - return SvcWrap_QueryProcessMemory64(system); + return SvcWrap_QueryProcessMemory64(system, args); case SvcId::MapProcessCodeMemory: - return SvcWrap_MapProcessCodeMemory64(system); + return SvcWrap_MapProcessCodeMemory64(system, args); case SvcId::UnmapProcessCodeMemory: - return SvcWrap_UnmapProcessCodeMemory64(system); + return SvcWrap_UnmapProcessCodeMemory64(system, args); case SvcId::CreateProcess: - return SvcWrap_CreateProcess64(system); + return SvcWrap_CreateProcess64(system, args); case SvcId::StartProcess: - return SvcWrap_StartProcess64(system); + return SvcWrap_StartProcess64(system, args); case SvcId::TerminateProcess: - return SvcWrap_TerminateProcess64(system); + return SvcWrap_TerminateProcess64(system, args); case SvcId::GetProcessInfo: - return SvcWrap_GetProcessInfo64(system); + return SvcWrap_GetProcessInfo64(system, args); case SvcId::CreateResourceLimit: - return SvcWrap_CreateResourceLimit64(system); + return SvcWrap_CreateResourceLimit64(system, args); case SvcId::SetResourceLimitLimitValue: - return SvcWrap_SetResourceLimitLimitValue64(system); + return SvcWrap_SetResourceLimitLimitValue64(system, args); case SvcId::CallSecureMonitor: - return SvcWrap_CallSecureMonitor64(system); + return SvcWrap_CallSecureMonitor64(system, args); case SvcId::MapInsecureMemory: - return SvcWrap_MapInsecureMemory64(system); + return SvcWrap_MapInsecureMemory64(system, args); case SvcId::UnmapInsecureMemory: - return SvcWrap_UnmapInsecureMemory64(system); + return SvcWrap_UnmapInsecureMemory64(system, args); default: LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm); break; @@ -4424,15 +4424,20 @@ static void Call64(Core::System& system, u32 imm) { void Call(Core::System& system, u32 imm) { auto& kernel = system.Kernel(); + auto& process = GetCurrentProcess(kernel); + + std::array<uint64_t, 8> args; + kernel.CurrentPhysicalCore().SaveSvcArguments(process, args); kernel.EnterSVCProfile(); - if (GetCurrentProcess(system.Kernel()).Is64Bit()) { - Call64(system, imm); + if (process.Is64Bit()) { + Call64(system, imm, args); } else { - Call32(system, imm); + Call32(system, imm, args); } kernel.ExitSVCProfile(); + kernel.CurrentPhysicalCore().LoadSvcArguments(process, args); } } // namespace Kernel::Svc diff --git a/src/core/hle/kernel/svc.h b/src/core/hle/kernel/svc.h index ac4696008..828f39611 100644 --- a/src/core/hle/kernel/svc.h +++ b/src/core/hle/kernel/svc.h @@ -9,6 +9,8 @@ namespace Core { class System; } +#include <span> + #include "common/common_types.h" #include "core/hle/kernel/svc_types.h" #include "core/hle/result.h" @@ -520,15 +522,15 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args); // Defined in svc_light_ipc.cpp. -void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system); -void SvcWrap_ReplyAndReceiveLight64(Core::System& system); +void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args); -void SvcWrap_SendSyncRequestLight64From32(Core::System& system); -void SvcWrap_SendSyncRequestLight64(Core::System& system); +void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args); // Defined in svc_secure_monitor_call.cpp. -void SvcWrap_CallSecureMonitor64From32(Core::System& system); -void SvcWrap_CallSecureMonitor64(Core::System& system); +void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args); // Perform a supervisor call by index. void Call(Core::System& system, u32 imm); diff --git a/src/core/hle/kernel/svc/svc_exception.cpp b/src/core/hle/kernel/svc/svc_exception.cpp index c581c086b..47b756828 100644 --- a/src/core/hle/kernel/svc/svc_exception.cpp +++ b/src/core/hle/kernel/svc/svc_exception.cpp @@ -103,9 +103,7 @@ void Break(Core::System& system, BreakReason reason, u64 info1, u64 info2) { handle_debug_buffer(info1, info2); - auto* const current_thread = GetCurrentThreadPointer(system.Kernel()); - const auto thread_processor_id = current_thread->GetActiveCore(); - system.ArmInterface(static_cast<std::size_t>(thread_processor_id)).LogBacktrace(); + system.CurrentPhysicalCore().LogBacktrace(); } const bool is_hbl = GetCurrentProcess(system.Kernel()).IsHbl(); diff --git a/src/core/hle/kernel/svc/svc_ipc.cpp b/src/core/hle/kernel/svc/svc_ipc.cpp index 6b5e1cb8d..47a3e7bb0 100644 --- a/src/core/hle/kernel/svc/svc_ipc.cpp +++ b/src/core/hle/kernel/svc/svc_ipc.cpp @@ -7,59 +7,127 @@ #include "core/hle/kernel/k_client_session.h" #include "core/hle/kernel/k_hardware_timer.h" #include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_scoped_resource_reservation.h" #include "core/hle/kernel/k_server_session.h" +#include "core/hle/kernel/k_session.h" #include "core/hle/kernel/svc.h" #include "core/hle/kernel/svc_results.h" namespace Kernel::Svc { -/// Makes a blocking IPC call to a service. -Result SendSyncRequest(Core::System& system, Handle handle) { - // Get the client session from its handle. +namespace { + +Result SendSyncRequestImpl(KernelCore& kernel, uintptr_t message, size_t buffer_size, + Handle session_handle) { + // Get the client session. KScopedAutoObject session = - GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KClientSession>(handle); + GetCurrentProcess(kernel).GetHandleTable().GetObject<KClientSession>(session_handle); R_UNLESS(session.IsNotNull(), ResultInvalidHandle); - LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}", handle); + // Get the parent, and persist a reference to it until we're done. + KScopedAutoObject parent = session->GetParent(); + ASSERT(parent.IsNotNull()); - R_RETURN(session->SendSyncRequest()); + // Send the request. + R_RETURN(session->SendSyncRequest(message, buffer_size)); } -Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message_buffer, - uint64_t message_buffer_size, Handle session_handle) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); -} +Result ReplyAndReceiveImpl(KernelCore& kernel, int32_t* out_index, uintptr_t message, + size_t buffer_size, KPhysicalAddress message_paddr, + KSynchronizationObject** objs, int32_t num_objects, Handle reply_target, + int64_t timeout_ns) { + // Reply to the target, if one is specified. + if (reply_target != InvalidHandle) { + KScopedAutoObject session = + GetCurrentProcess(kernel).GetHandleTable().GetObject<KServerSession>(reply_target); + R_UNLESS(session.IsNotNull(), ResultInvalidHandle); -Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle, - uint64_t message_buffer, uint64_t message_buffer_size, - Handle session_handle) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); + // If we fail to reply, we want to set the output index to -1. + ON_RESULT_FAILURE { + *out_index = -1; + }; + + // Send the reply. + R_TRY(session->SendReply()); + // R_TRY(session->SendReply(message, buffer_size, message_paddr)); + } + + // Receive a message. + { + // Convert the timeout from nanoseconds to ticks. + // NOTE: Nintendo does not use this conversion logic in WaitSynchronization... + s64 timeout; + if (timeout_ns > 0) { + const s64 offset_tick(timeout_ns); + if (offset_tick > 0) { + timeout = kernel.HardwareTimer().GetTick() + offset_tick + 2; + if (timeout <= 0) { + timeout = std::numeric_limits<s64>::max(); + } + } else { + timeout = std::numeric_limits<s64>::max(); + } + } else { + timeout = timeout_ns; + } + + // Wait for a message. + while (true) { + // Wait for an object. + s32 index; + Result result = KSynchronizationObject::Wait(kernel, std::addressof(index), objs, + num_objects, timeout); + if (ResultTimedOut == result) { + R_THROW(result); + } + + // Receive the request. + if (R_SUCCEEDED(result)) { + KServerSession* session = objs[index]->DynamicCast<KServerSession*>(); + if (session != nullptr) { + // result = session->ReceiveRequest(message, buffer_size, message_paddr); + result = session->ReceiveRequest(); + if (ResultNotFound == result) { + continue; + } + } + } + + *out_index = index; + R_RETURN(result); + } + } } -Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_addr, s32 num_handles, - Handle reply_target, s64 timeout_ns) { +Result ReplyAndReceiveImpl(KernelCore& kernel, int32_t* out_index, uintptr_t message, + size_t buffer_size, KPhysicalAddress message_paddr, + KProcessAddress user_handles, int32_t num_handles, Handle reply_target, + int64_t timeout_ns) { // Ensure number of handles is valid. - R_UNLESS(0 <= num_handles && num_handles <= ArgumentHandleCountMax, ResultOutOfRange); + R_UNLESS(0 <= num_handles && num_handles <= Svc::ArgumentHandleCountMax, ResultOutOfRange); // Get the synchronization context. - auto& kernel = system.Kernel(); - auto& handle_table = GetCurrentProcess(kernel).GetHandleTable(); - auto objs = GetCurrentThread(kernel).GetSynchronizationObjectBuffer(); - auto handles = GetCurrentThread(kernel).GetHandleBuffer(); + auto& process = GetCurrentProcess(kernel); + auto& thread = GetCurrentThread(kernel); + auto& handle_table = process.GetHandleTable(); + KSynchronizationObject** objs = thread.GetSynchronizationObjectBuffer().data(); + Handle* handles = thread.GetHandleBuffer().data(); // Copy user handles. if (num_handles > 0) { - // Get the handles. - R_UNLESS(GetCurrentMemory(kernel).ReadBlock(handles_addr, handles.data(), - sizeof(Handle) * num_handles), + // Ensure that we can try to get the handles. + R_UNLESS(process.GetPageTable().Contains(user_handles, num_handles * sizeof(Handle)), ResultInvalidPointer); + // Get the handles + R_UNLESS( + GetCurrentMemory(kernel).ReadBlock(user_handles, handles, sizeof(Handle) * num_handles), + ResultInvalidPointer); + // Convert the handles to objects. - R_UNLESS(handle_table.GetMultipleObjects<KSynchronizationObject>( - objs.data(), handles.data(), num_handles), - ResultInvalidHandle); + R_UNLESS( + handle_table.GetMultipleObjects<KSynchronizationObject>(objs, handles, num_handles), + ResultInvalidHandle); } // Ensure handles are closed when we're done. @@ -69,69 +137,135 @@ Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_ad } }); - // Reply to the target, if one is specified. - if (reply_target != InvalidHandle) { - KScopedAutoObject session = handle_table.GetObject<KServerSession>(reply_target); - R_UNLESS(session.IsNotNull(), ResultInvalidHandle); + R_RETURN(ReplyAndReceiveImpl(kernel, out_index, message, buffer_size, message_paddr, objs, + num_handles, reply_target, timeout_ns)); +} - // If we fail to reply, we want to set the output index to -1. +} // namespace + +/// Makes a blocking IPC call to a service. +Result SendSyncRequest(Core::System& system, Handle session_handle) { + R_RETURN(SendSyncRequestImpl(system.Kernel(), 0, 0, session_handle)); +} + +Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message, uint64_t buffer_size, + Handle session_handle) { + auto& kernel = system.Kernel(); + + // Validate that the message buffer is page aligned and does not overflow. + R_UNLESS(Common::IsAligned(message, PageSize), ResultInvalidAddress); + R_UNLESS(buffer_size > 0, ResultInvalidSize); + R_UNLESS(Common::IsAligned(buffer_size, PageSize), ResultInvalidSize); + R_UNLESS(message < message + buffer_size, ResultInvalidCurrentMemory); + + // Get the process page table. + auto& page_table = GetCurrentProcess(kernel).GetPageTable(); + + // Lock the message buffer. + R_TRY(page_table.LockForIpcUserBuffer(nullptr, message, buffer_size)); + + { + // If we fail to send the message, unlock the message buffer. ON_RESULT_FAILURE { - *out_index = -1; + page_table.UnlockForIpcUserBuffer(message, buffer_size); }; - // Send the reply. - R_TRY(session->SendReply()); + // Send the request. + ASSERT(message != 0); + R_TRY(SendSyncRequestImpl(kernel, message, buffer_size, session_handle)); } - // Convert the timeout from nanoseconds to ticks. - // NOTE: Nintendo does not use this conversion logic in WaitSynchronization... - s64 timeout; - if (timeout_ns > 0) { - const s64 offset_tick(timeout_ns); - if (offset_tick > 0) { - timeout = kernel.HardwareTimer().GetTick() + offset_tick + 2; - if (timeout <= 0) { - timeout = std::numeric_limits<s64>::max(); - } - } else { - timeout = std::numeric_limits<s64>::max(); - } - } else { - timeout = timeout_ns; - } + // We successfully processed, so try to unlock the message buffer. + R_RETURN(page_table.UnlockForIpcUserBuffer(message, buffer_size)); +} - // Wait for a message. - while (true) { - // Wait for an object. - s32 index; - Result result = KSynchronizationObject::Wait(kernel, std::addressof(index), objs.data(), - num_handles, timeout); - if (result == ResultTimedOut) { - R_RETURN(result); - } +Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle, + uint64_t message, uint64_t buffer_size, + Handle session_handle) { + // Get the process and handle table. + auto& process = GetCurrentProcess(system.Kernel()); + auto& handle_table = process.GetHandleTable(); - // Receive the request. - if (R_SUCCEEDED(result)) { - KServerSession* session = objs[index]->DynamicCast<KServerSession*>(); - if (session != nullptr) { - result = session->ReceiveRequest(); - if (result == ResultNotFound) { - continue; - } - } - } + // Reserve a new event from the process resource limit. + KScopedResourceReservation event_reservation(std::addressof(process), + Svc::LimitableResource::EventCountMax); + R_UNLESS(event_reservation.Succeeded(), ResultLimitReached); - *out_index = index; - R_RETURN(result); - } + // Get the client session. + KScopedAutoObject session = process.GetHandleTable().GetObject<KClientSession>(session_handle); + R_UNLESS(session.IsNotNull(), ResultInvalidHandle); + + // Get the parent, and persist a reference to it until we're done. + KScopedAutoObject parent = session->GetParent(); + ASSERT(parent.IsNotNull()); + + // Create a new event. + KEvent* event = KEvent::Create(system.Kernel()); + R_UNLESS(event != nullptr, ResultOutOfResource); + + // Initialize the event. + event->Initialize(std::addressof(process)); + + // Commit our reservation. + event_reservation.Commit(); + + // At end of scope, kill the standing references to the sub events. + SCOPE_EXIT({ + event->GetReadableEvent().Close(); + event->Close(); + }); + + // Register the event. + KEvent::Register(system.Kernel(), event); + + // Add the readable event to the handle table. + R_TRY(handle_table.Add(out_event_handle, std::addressof(event->GetReadableEvent()))); + + // Ensure that if we fail to send the request, we close the readable handle. + ON_RESULT_FAILURE { + handle_table.Remove(*out_event_handle); + }; + + // Send the async request. + R_RETURN(session->SendAsyncRequest(event, message, buffer_size)); } -Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index, - uint64_t message_buffer, uint64_t message_buffer_size, - uint64_t handles, int32_t num_handles, Handle reply_target, - int64_t timeout_ns) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); +Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles, s32 num_handles, + Handle reply_target, s64 timeout_ns) { + R_RETURN(ReplyAndReceiveImpl(system.Kernel(), out_index, 0, 0, 0, handles, num_handles, + reply_target, timeout_ns)); +} + +Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index, uint64_t message, + uint64_t buffer_size, uint64_t handles, int32_t num_handles, + Handle reply_target, int64_t timeout_ns) { + // Validate that the message buffer is page aligned and does not overflow. + R_UNLESS(Common::IsAligned(message, PageSize), ResultInvalidAddress); + R_UNLESS(buffer_size > 0, ResultInvalidSize); + R_UNLESS(Common::IsAligned(buffer_size, PageSize), ResultInvalidSize); + R_UNLESS(message < message + buffer_size, ResultInvalidCurrentMemory); + + // Get the process page table. + auto& page_table = GetCurrentProcess(system.Kernel()).GetPageTable(); + + // Lock the message buffer, getting its physical address. + KPhysicalAddress message_paddr; + R_TRY(page_table.LockForIpcUserBuffer(std::addressof(message_paddr), message, buffer_size)); + + { + // If we fail to send the message, unlock the message buffer. + ON_RESULT_FAILURE { + page_table.UnlockForIpcUserBuffer(message, buffer_size); + }; + + // Reply/Receive the request. + ASSERT(message != 0); + R_TRY(ReplyAndReceiveImpl(system.Kernel(), out_index, message, buffer_size, message_paddr, + handles, num_handles, reply_target, timeout_ns)); + } + + // We successfully processed, so try to unlock the message buffer. + R_RETURN(page_table.UnlockForIpcUserBuffer(message, buffer_size)); } Result SendSyncRequest64(Core::System& system, Handle session_handle) { diff --git a/src/core/hle/kernel/svc/svc_light_ipc.cpp b/src/core/hle/kernel/svc/svc_light_ipc.cpp index b76ce984c..4772cbda1 100644 --- a/src/core/hle/kernel/svc/svc_light_ipc.cpp +++ b/src/core/hle/kernel/svc/svc_light_ipc.cpp @@ -1,21 +1,40 @@ // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include "core/arm/arm_interface.h" #include "core/core.h" +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/svc.h" #include "core/hle/kernel/svc_results.h" namespace Kernel::Svc { Result SendSyncRequestLight(Core::System& system, Handle session_handle, u32* args) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); + // Get the light client session from its handle. + KScopedAutoObject session = GetCurrentProcess(system.Kernel()) + .GetHandleTable() + .GetObject<KLightClientSession>(session_handle); + R_UNLESS(session.IsNotNull(), ResultInvalidHandle); + + // Send the request. + R_TRY(session->SendSyncRequest(args)); + + R_SUCCEED(); } Result ReplyAndReceiveLight(Core::System& system, Handle session_handle, u32* args) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); + // Get the light server session from its handle. + KScopedAutoObject session = GetCurrentProcess(system.Kernel()) + .GetHandleTable() + .GetObject<KLightServerSession>(session_handle); + R_UNLESS(session.IsNotNull(), ResultInvalidHandle); + + // Handle the request. + R_TRY(session->ReplyAndReceive(args)); + + R_SUCCEED(); } Result SendSyncRequestLight64(Core::System& system, Handle session_handle, u32* args) { @@ -37,37 +56,36 @@ Result ReplyAndReceiveLight64From32(Core::System& system, Handle session_handle, // Custom ABI implementation for light IPC. template <typename F> -static void SvcWrap_LightIpc(Core::System& system, F&& cb) { - auto& core = system.CurrentArmInterface(); - std::array<u32, 7> arguments{}; +static void SvcWrap_LightIpc(Core::System& system, std::span<uint64_t, 8> args, F&& cb) { + std::array<u32, 7> ipc_args{}; - Handle session_handle = static_cast<Handle>(core.GetReg(0)); + Handle session_handle = static_cast<Handle>(args[0]); for (int i = 0; i < 7; i++) { - arguments[i] = static_cast<u32>(core.GetReg(i + 1)); + ipc_args[i] = static_cast<u32>(args[i + 1]); } - Result ret = cb(system, session_handle, arguments.data()); + Result ret = cb(system, session_handle, ipc_args.data()); - core.SetReg(0, ret.raw); + args[0] = ret.raw; for (int i = 0; i < 7; i++) { - core.SetReg(i + 1, arguments[i]); + args[i + 1] = ipc_args[i]; } } -void SvcWrap_SendSyncRequestLight64(Core::System& system) { - SvcWrap_LightIpc(system, SendSyncRequestLight64); +void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, SendSyncRequestLight64); } -void SvcWrap_ReplyAndReceiveLight64(Core::System& system) { - SvcWrap_LightIpc(system, ReplyAndReceiveLight64); +void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, ReplyAndReceiveLight64); } -void SvcWrap_SendSyncRequestLight64From32(Core::System& system) { - SvcWrap_LightIpc(system, SendSyncRequestLight64From32); +void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, SendSyncRequestLight64From32); } -void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system) { - SvcWrap_LightIpc(system, ReplyAndReceiveLight64From32); +void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, ReplyAndReceiveLight64From32); } } // namespace Kernel::Svc diff --git a/src/core/hle/kernel/svc/svc_port.cpp b/src/core/hle/kernel/svc/svc_port.cpp index abba757c7..737749f7d 100644 --- a/src/core/hle/kernel/svc/svc_port.cpp +++ b/src/core/hle/kernel/svc/svc_port.cpp @@ -5,6 +5,7 @@ #include "core/core.h" #include "core/hle/kernel/k_client_port.h" #include "core/hle/kernel/k_client_session.h" +#include "core/hle/kernel/k_light_client_session.h" #include "core/hle/kernel/k_object_name.h" #include "core/hle/kernel/k_port.h" #include "core/hle/kernel/k_process.h" @@ -51,13 +52,73 @@ Result ConnectToNamedPort(Core::System& system, Handle* out, u64 user_name) { Result CreatePort(Core::System& system, Handle* out_server, Handle* out_client, int32_t max_sessions, bool is_light, uint64_t name) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); + auto& kernel = system.Kernel(); + + // Ensure max sessions is valid. + R_UNLESS(max_sessions > 0, ResultOutOfRange); + + // Get the current handle table. + auto& handle_table = GetCurrentProcess(kernel).GetHandleTable(); + + // Create a new port. + KPort* port = KPort::Create(kernel); + R_UNLESS(port != nullptr, ResultOutOfResource); + + // Initialize the port. + port->Initialize(max_sessions, is_light, name); + + // Ensure that we clean up the port (and its only references are handle table) on function end. + SCOPE_EXIT({ + port->GetServerPort().Close(); + port->GetClientPort().Close(); + }); + + // Register the port. + KPort::Register(kernel, port); + + // Add the client to the handle table. + R_TRY(handle_table.Add(out_client, std::addressof(port->GetClientPort()))); + + // Ensure that we maintain a clean handle state on exit. + ON_RESULT_FAILURE { + handle_table.Remove(*out_client); + }; + + // Add the server to the handle table. + R_RETURN(handle_table.Add(out_server, std::addressof(port->GetServerPort()))); } -Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); +Result ConnectToPort(Core::System& system, Handle* out, Handle port) { + // Get the current handle table. + auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable(); + + // Get the client port. + KScopedAutoObject client_port = handle_table.GetObject<KClientPort>(port); + R_UNLESS(client_port.IsNotNull(), ResultInvalidHandle); + + // Reserve a handle for the port. + // NOTE: Nintendo really does write directly to the output handle here. + R_TRY(handle_table.Reserve(out)); + ON_RESULT_FAILURE { + handle_table.Unreserve(*out); + }; + + // Create the session. + KAutoObject* session; + if (client_port->IsLight()) { + R_TRY(client_port->CreateLightSession( + reinterpret_cast<KLightClientSession**>(std::addressof(session)))); + } else { + R_TRY(client_port->CreateSession( + reinterpret_cast<KClientSession**>(std::addressof(session)))); + } + + // Register the session. + handle_table.Register(*out, session); + session->Close(); + + // We succeeded. + R_SUCCEED(); } Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t user_name, diff --git a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp index 62c781551..48b564ec8 100644 --- a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp +++ b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp @@ -22,31 +22,29 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen // Custom ABI for CallSecureMonitor. -void SvcWrap_CallSecureMonitor64(Core::System& system) { - auto& core = system.CurrentPhysicalCore().ArmInterface(); - lp64::SecureMonitorArguments args{}; +void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args) { + lp64::SecureMonitorArguments smc_args{}; for (int i = 0; i < 8; i++) { - args.r[i] = core.GetReg(i); + smc_args.r[i] = args[i]; } - CallSecureMonitor64(system, std::addressof(args)); + CallSecureMonitor64(system, std::addressof(smc_args)); for (int i = 0; i < 8; i++) { - core.SetReg(i, args.r[i]); + args[i] = smc_args.r[i]; } } -void SvcWrap_CallSecureMonitor64From32(Core::System& system) { - auto& core = system.CurrentPhysicalCore().ArmInterface(); - ilp32::SecureMonitorArguments args{}; +void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args) { + ilp32::SecureMonitorArguments smc_args{}; for (int i = 0; i < 8; i++) { - args.r[i] = static_cast<u32>(core.GetReg(i)); + smc_args.r[i] = static_cast<u32>(args[i]); } - CallSecureMonitor64From32(system, std::addressof(args)); + CallSecureMonitor64From32(system, std::addressof(smc_args)); for (int i = 0; i < 8; i++) { - core.SetReg(i, args.r[i]); + args[i] = smc_args.r[i]; } } diff --git a/src/core/hle/kernel/svc/svc_session.cpp b/src/core/hle/kernel/svc/svc_session.cpp index 01b8a52ad..2f5905f32 100644 --- a/src/core/hle/kernel/svc/svc_session.cpp +++ b/src/core/hle/kernel/svc/svc_session.cpp @@ -3,8 +3,10 @@ #include "common/scope_exit.h" #include "core/core.h" +#include "core/hle/kernel/k_light_session.h" #include "core/hle/kernel/k_process.h" #include "core/hle/kernel/k_scoped_resource_reservation.h" +#include "core/hle/kernel/k_server_port.h" #include "core/hle/kernel/k_session.h" #include "core/hle/kernel/svc.h" @@ -20,7 +22,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien T* session; // Reserve a new session from the process resource limit. - // FIXME: LimitableResource_SessionCountMax + // TODO: Dynamic resource limits KScopedResourceReservation session_reservation(std::addressof(process), LimitableResource::SessionCountMax); if (session_reservation.Succeeded()) { @@ -92,16 +94,42 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, bool is_light, u64 name) { if (is_light) { - // return CreateSession<KLightSession>(system, out_server, out_client, name); - R_THROW(ResultNotImplemented); + R_RETURN(CreateSession<KLightSession>(system, out_server, out_client, name)); } else { R_RETURN(CreateSession<KSession>(system, out_server, out_client, name)); } } -Result AcceptSession(Core::System& system, Handle* out_handle, Handle port_handle) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); +Result AcceptSession(Core::System& system, Handle* out, Handle port_handle) { + // Get the current handle table. + auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable(); + + // Get the server port. + KScopedAutoObject port = handle_table.GetObject<KServerPort>(port_handle); + R_UNLESS(port.IsNotNull(), ResultInvalidHandle); + + // Reserve an entry for the new session. + R_TRY(handle_table.Reserve(out)); + ON_RESULT_FAILURE { + handle_table.Unreserve(*out); + }; + + // Accept the session. + KAutoObject* session; + if (port->IsLight()) { + session = port->AcceptLightSession(); + } else { + session = port->AcceptSession(); + } + + // Ensure we accepted successfully. + R_UNLESS(session != nullptr, ResultNotFound); + + // Register the session. + handle_table.Register(*out, session); + session->Close(); + + R_SUCCEED(); } Result CreateSession64(Core::System& system, Handle* out_server_session_handle, diff --git a/src/core/hle/kernel/svc/svc_thread.cpp b/src/core/hle/kernel/svc/svc_thread.cpp index 755fd62b5..7681afa33 100644 --- a/src/core/hle/kernel/svc/svc_thread.cpp +++ b/src/core/hle/kernel/svc/svc_thread.cpp @@ -90,8 +90,6 @@ Result StartThread(Core::System& system, Handle thread_handle) { /// Called when a thread exits void ExitThread(Core::System& system) { - LOG_DEBUG(Kernel_SVC, "called, pc=0x{:08X}", system.CurrentArmInterface().GetPC()); - auto* const current_thread = GetCurrentThreadPointer(system.Kernel()); system.GlobalSchedulerContext().RemoveThread(current_thread); current_thread->Exit(); @@ -147,47 +145,19 @@ Result GetThreadContext3(Core::System& system, u64 out_context, Handle thread_ha R_UNLESS(thread.IsNotNull(), ResultInvalidHandle); // Require the handle be to a non-current thread in the current process. - const auto* current_process = GetCurrentProcessPointer(kernel); - R_UNLESS(current_process == thread->GetOwnerProcess(), ResultInvalidId); - - // Verify that the thread isn't terminated. - R_UNLESS(thread->GetState() != ThreadState::Terminated, ResultTerminationRequested); - - /// Check that the thread is not the current one. - /// NOTE: Nintendo does not check this, and thus the following loop will deadlock. - R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(kernel), ResultInvalidId); - - // Try to get the thread context until the thread isn't current on any core. - while (true) { - KScopedSchedulerLock sl{kernel}; - - // TODO(bunnei): Enforce that thread is suspended for debug here. - - // If the thread's raw state isn't runnable, check if it's current on some core. - if (thread->GetRawState() != ThreadState::Runnable) { - bool current = false; - for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) { - if (thread.GetPointerUnsafe() == kernel.Scheduler(i).GetSchedulerCurrentThread()) { - current = true; - break; - } - } + R_UNLESS(thread->GetOwnerProcess() == GetCurrentProcessPointer(kernel), ResultInvalidHandle); + R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(kernel), ResultBusy); - // If the thread is current, retry until it isn't. - if (current) { - continue; - } - } + // Get the thread context. + Svc::ThreadContext context{}; + R_TRY(thread->GetThreadContext3(std::addressof(context))); - // Get the thread context. - static thread_local Common::ScratchBuffer<u8> context; - R_TRY(thread->GetThreadContext3(context)); + // Copy the thread context to user space. + R_UNLESS( + GetCurrentMemory(kernel).WriteBlock(out_context, std::addressof(context), sizeof(context)), + ResultInvalidPointer); - // Copy the thread context to user space. - GetCurrentMemory(kernel).WriteBlock(out_context, context.data(), context.size()); - - R_SUCCEED(); - } + R_SUCCEED(); } /// Gets the priority for the specified thread diff --git a/src/core/hle/kernel/svc_generator.py b/src/core/hle/kernel/svc_generator.py index 5531faac6..786189ab7 100644 --- a/src/core/hle/kernel/svc_generator.py +++ b/src/core/hle/kernel/svc_generator.py @@ -374,11 +374,11 @@ def get_registers(parse_result, bitness): # Collects possibly multiple source registers into the named C++ value. def emit_gather(sources, name, type_name, reg_size): - get_fn = f"GetReg{reg_size*8}" + get_fn = f"GetArg{reg_size*8}" if len(sources) == 1: s, = sources - line = f"{name} = Convert<{type_name}>({get_fn}(system, {s}));" + line = f"{name} = Convert<{type_name}>({get_fn}(args, {s}));" return [line] var_type = f"std::array<uint{reg_size*8}_t, {len(sources)}>" @@ -387,7 +387,7 @@ def emit_gather(sources, name, type_name, reg_size): ] for i in range(0, len(sources)): lines.append( - f"{name}_gather[{i}] = {get_fn}(system, {sources[i]});") + f"{name}_gather[{i}] = {get_fn}(args, {sources[i]});") lines.append(f"{name} = Convert<{type_name}>({name}_gather);") return lines @@ -396,12 +396,12 @@ def emit_gather(sources, name, type_name, reg_size): # Produces one or more statements which assign the named C++ value # into possibly multiple registers. def emit_scatter(destinations, name, reg_size): - set_fn = f"SetReg{reg_size*8}" + set_fn = f"SetArg{reg_size*8}" reg_type = f"uint{reg_size*8}_t" if len(destinations) == 1: d, = destinations - line = f"{set_fn}(system, {d}, Convert<{reg_type}>({name}));" + line = f"{set_fn}(args, {d}, Convert<{reg_type}>({name}));" return [line] var_type = f"std::array<{reg_type}, {len(destinations)}>" @@ -411,7 +411,7 @@ def emit_scatter(destinations, name, reg_size): for i in range(0, len(destinations)): lines.append( - f"{set_fn}(system, {destinations[i]}, {name}_scatter[{i}]);") + f"{set_fn}(args, {destinations[i]}, {name}_scatter[{i}]);") return lines @@ -433,7 +433,7 @@ def emit_lines(lines, indent=' '): def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size): return_write, output_writes, input_reads = register_info lines = [ - f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system) {{" + f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system, std::span<uint64_t, 8> args) {{" ] # Get everything ready. @@ -498,6 +498,8 @@ namespace Core { class System; } +#include <span> + #include "common/common_types.h" #include "core/hle/kernel/svc_types.h" #include "core/hle/result.h" @@ -524,15 +526,15 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args); // Defined in svc_light_ipc.cpp. -void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system); -void SvcWrap_ReplyAndReceiveLight64(Core::System& system); +void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args); -void SvcWrap_SendSyncRequestLight64From32(Core::System& system); -void SvcWrap_SendSyncRequestLight64(Core::System& system); +void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args); // Defined in svc_secure_monitor_call.cpp. -void SvcWrap_CallSecureMonitor64From32(Core::System& system); -void SvcWrap_CallSecureMonitor64(Core::System& system); +void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args); // Perform a supervisor call by index. void Call(Core::System& system, u32 imm); @@ -550,20 +552,20 @@ PROLOGUE_CPP = """ namespace Kernel::Svc { -static uint32_t GetReg32(Core::System& system, int n) { - return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n)); +static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) { + return static_cast<uint32_t>(args[n]); } -static void SetReg32(Core::System& system, int n, uint32_t result) { - system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result)); +static void SetArg32(std::span<uint64_t, 8> args, int n, uint32_t result) { + args[n] = result; } -static uint64_t GetReg64(Core::System& system, int n) { - return system.CurrentArmInterface().GetReg(n); +static uint64_t GetArg64(std::span<uint64_t, 8> args, int n) { + return args[n]; } -static void SetReg64(Core::System& system, int n, uint64_t result) { - system.CurrentArmInterface().SetReg(n, result); +static void SetArg64(std::span<uint64_t, 8> args, int n, uint64_t result) { + args[n] = result; } // Like bit_cast, but handles the case when the source and dest @@ -590,15 +592,20 @@ EPILOGUE_CPP = """ void Call(Core::System& system, u32 imm) { auto& kernel = system.Kernel(); + auto& process = GetCurrentProcess(kernel); + + std::array<uint64_t, 8> args; + kernel.CurrentPhysicalCore().SaveSvcArguments(process, args); kernel.EnterSVCProfile(); - if (GetCurrentProcess(system.Kernel()).Is64Bit()) { - Call64(system, imm); + if (process.Is64Bit()) { + Call64(system, imm, args); } else { - Call32(system, imm); + Call32(system, imm, args); } kernel.ExitSVCProfile(); + kernel.CurrentPhysicalCore().LoadSvcArguments(process, args); } } // namespace Kernel::Svc @@ -609,13 +616,13 @@ def emit_call(bitness, names, suffix): bit_size = REG_SIZES[bitness]*8 indent = " " lines = [ - f"static void Call{bit_size}(Core::System& system, u32 imm) {{", + f"static void Call{bit_size}(Core::System& system, u32 imm, std::span<uint64_t, 8> args) {{", f"{indent}switch (static_cast<SvcId>(imm)) {{" ] for _, name in names: lines.append(f"{indent}case SvcId::{name}:") - lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system);") + lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system, args);") lines.append(f"{indent}default:") lines.append( diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp index 126cd6ffd..b1310d6e4 100644 --- a/src/core/hle/service/filesystem/fsp_srv.cpp +++ b/src/core/hle/service/filesystem/fsp_srv.cpp @@ -246,7 +246,13 @@ static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vec entries.reserve(entries.size() + new_data.size()); for (const auto& new_entry : new_data) { - entries.emplace_back(new_entry->GetName(), type, + auto name = new_entry->GetName(); + + if (type == FileSys::EntryType::File && name == FileSys::GetSaveDataSizeFileName()) { + continue; + } + + entries.emplace_back(name, type, type == FileSys::EntryType::Directory ? 0 : new_entry->GetSize()); } } diff --git a/src/core/hle/service/hid/controllers/applet_resource.cpp b/src/core/hle/service/hid/controllers/applet_resource.cpp new file mode 100644 index 000000000..c8e74c764 --- /dev/null +++ b/src/core/hle/service/hid/controllers/applet_resource.cpp @@ -0,0 +1,313 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "core/core.h" +#include "core/hle/kernel/k_shared_memory.h" +#include "core/hle/service/hid/controllers/applet_resource.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" +#include "core/hle/service/hid/errors.h" + +namespace Service::HID { + +AppletResource::AppletResource(Core::System& system_) : system{system_} {} + +AppletResource::~AppletResource() = default; + +Result AppletResource::CreateAppletResource(u64 aruid) { + const u64 index = GetIndexFromAruid(aruid); + + if (index >= AruidIndexMax) { + return ResultAruidNotRegistered; + } + + if (data[index].flag.is_assigned) { + return ResultAruidAlreadyRegistered; + } + + auto& shared_memory = shared_memory_holder[index]; + if (!shared_memory.IsMapped()) { + const Result result = shared_memory.Initialize(system); + if (result.IsError()) { + return result; + } + if (shared_memory.GetAddress() == nullptr) { + shared_memory.Finalize(); + return ResultSharedMemoryNotInitialized; + } + } + + auto* shared_memory_format = shared_memory.GetAddress(); + if (shared_memory_format != nullptr) { + shared_memory_format->Initialize(); + } + + data[index].shared_memory_format = shared_memory_format; + data[index].flag.is_assigned.Assign(true); + // TODO: InitializeSixAxisControllerConfig(false); + active_aruid = aruid; + return ResultSuccess; +} + +Result AppletResource::RegisterAppletResourceUserId(u64 aruid, bool enable_input) { + const u64 index = GetIndexFromAruid(aruid); + + if (index < AruidIndexMax) { + return ResultAruidAlreadyRegistered; + } + + std::size_t data_index = AruidIndexMax; + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (!data[i].flag.is_initialized) { + data_index = i; + break; + } + } + + if (data_index == AruidIndexMax) { + return ResultAruidNoAvailableEntries; + } + + AruidData& aruid_data = data[data_index]; + + aruid_data.aruid = aruid; + aruid_data.flag.is_initialized.Assign(true); + if (enable_input) { + aruid_data.flag.enable_pad_input.Assign(true); + aruid_data.flag.enable_six_axis_sensor.Assign(true); + aruid_data.flag.bit_18.Assign(true); + aruid_data.flag.enable_touchscreen.Assign(true); + } + + data_index = AruidIndexMax; + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (registration_list.flag[i] == RegistrationStatus::Initialized) { + if (registration_list.aruid[i] != aruid) { + continue; + } + data_index = i; + break; + } + if (registration_list.flag[i] == RegistrationStatus::None) { + data_index = i; + break; + } + } + + if (data_index == AruidIndexMax) { + return ResultSuccess; + } + + registration_list.flag[data_index] = RegistrationStatus::Initialized; + registration_list.aruid[data_index] = aruid; + + return ResultSuccess; +} + +void AppletResource::UnregisterAppletResourceUserId(u64 aruid) { + u64 index = GetIndexFromAruid(aruid); + + if (index < AruidIndexMax) { + if (data[index].flag.is_assigned) { + data[index].shared_memory_format = nullptr; + data[index].flag.is_assigned.Assign(false); + } + } + + index = GetIndexFromAruid(aruid); + if (index < AruidIndexMax) { + DestroySevenSixAxisTransferMemory(); + data[index].flag.raw = 0; + data[index].aruid = 0; + + index = GetIndexFromAruid(aruid); + if (index < AruidIndexMax) { + registration_list.flag[index] = RegistrationStatus::PendingDelete; + } + } +} + +void AppletResource::FreeAppletResourceId(u64 aruid) { + u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + auto& aruid_data = data[index]; + if (aruid_data.flag.is_assigned) { + aruid_data.shared_memory_format = nullptr; + aruid_data.flag.is_assigned.Assign(false); + } +} + +u64 AppletResource::GetActiveAruid() { + return active_aruid; +} + +Result AppletResource::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) { + u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return ResultAruidNotRegistered; + } + + *out_handle = shared_memory_holder[index].GetHandle(); + return ResultSuccess; +} + +Result AppletResource::GetSharedMemoryFormat(SharedMemoryFormat** out_shared_memory_format, + u64 aruid) { + u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return ResultAruidNotRegistered; + } + + *out_shared_memory_format = data[index].shared_memory_format; + return ResultSuccess; +} + +u64 AppletResource::GetIndexFromAruid(u64 aruid) { + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (registration_list.flag[i] == RegistrationStatus::Initialized && + registration_list.aruid[i] == aruid) { + return i; + } + } + return AruidIndexMax; +} + +Result AppletResource::DestroySevenSixAxisTransferMemory() { + // TODO + return ResultSuccess; +} + +void AppletResource::EnableInput(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_pad_input.Assign(is_enabled); + data[index].flag.enable_touchscreen.Assign(is_enabled); +} + +void AppletResource::EnableSixAxisSensor(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_six_axis_sensor.Assign(is_enabled); +} + +void AppletResource::EnablePadInput(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_pad_input.Assign(is_enabled); +} + +void AppletResource::EnableTouchScreen(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_touchscreen.Assign(is_enabled); +} + +void AppletResource::SetIsPalmaConnectable(u64 aruid, bool is_connectable) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.is_palma_connectable.Assign(is_connectable); +} + +void AppletResource::EnablePalmaBoostMode(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_palma_boost_mode.Assign(is_enabled); +} + +Result AppletResource::RegisterCoreAppletResource() { + if (ref_counter == std::numeric_limits<s32>::max() - 1) { + return ResultAppletResourceOverflow; + } + if (ref_counter == 0) { + const u64 index = GetIndexFromAruid(0); + if (index < AruidIndexMax) { + return ResultAruidAlreadyRegistered; + } + + std::size_t data_index = AruidIndexMax; + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (!data[i].flag.is_initialized) { + data_index = i; + break; + } + } + + if (data_index == AruidIndexMax) { + return ResultAruidNoAvailableEntries; + } + + AruidData& aruid_data = data[data_index]; + + aruid_data.aruid = 0; + aruid_data.flag.is_initialized.Assign(true); + aruid_data.flag.enable_pad_input.Assign(true); + aruid_data.flag.enable_six_axis_sensor.Assign(true); + aruid_data.flag.bit_18.Assign(true); + aruid_data.flag.enable_touchscreen.Assign(true); + + data_index = AruidIndexMax; + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (registration_list.flag[i] == RegistrationStatus::Initialized) { + if (registration_list.aruid[i] != 0) { + continue; + } + data_index = i; + break; + } + if (registration_list.flag[i] == RegistrationStatus::None) { + data_index = i; + break; + } + } + + Result result = ResultSuccess; + + if (data_index == AruidIndexMax) { + result = CreateAppletResource(0); + } else { + registration_list.flag[data_index] = RegistrationStatus::Initialized; + registration_list.aruid[data_index] = 0; + } + + if (result.IsError()) { + UnregisterAppletResourceUserId(0); + return result; + } + } + ref_counter++; + return ResultSuccess; +} + +Result AppletResource::UnregisterCoreAppletResource() { + if (ref_counter == 0) { + return ResultAppletResourceNotInitialized; + } + + if (--ref_counter == 0) { + UnregisterAppletResourceUserId(0); + } + + return ResultSuccess; +} + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/applet_resource.h b/src/core/hle/service/hid/controllers/applet_resource.h new file mode 100644 index 000000000..e7991f93a --- /dev/null +++ b/src/core/hle/service/hid/controllers/applet_resource.h @@ -0,0 +1,98 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include <array> + +#include "common/bit_field.h" +#include "common/common_types.h" +#include "core/hle/result.h" +#include "core/hle/service/hid/controllers/shared_memory_holder.h" + +namespace Core { +class System; +} + +namespace Kernel { +class KSharedMemory; +} + +namespace Service::HID { +struct SharedMemoryFormat; + +class AppletResource { +public: + explicit AppletResource(Core::System& system_); + ~AppletResource(); + + Result CreateAppletResource(u64 aruid); + + Result RegisterAppletResourceUserId(u64 aruid, bool enable_input); + void UnregisterAppletResourceUserId(u64 aruid); + + void FreeAppletResourceId(u64 aruid); + + u64 GetActiveAruid(); + Result GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid); + Result GetSharedMemoryFormat(SharedMemoryFormat** out_shared_memory_format, u64 aruid); + + u64 GetIndexFromAruid(u64 aruid); + + Result DestroySevenSixAxisTransferMemory(); + + void EnableInput(u64 aruid, bool is_enabled); + void EnableSixAxisSensor(u64 aruid, bool is_enabled); + void EnablePadInput(u64 aruid, bool is_enabled); + void EnableTouchScreen(u64 aruid, bool is_enabled); + void SetIsPalmaConnectable(u64 aruid, bool is_connectable); + void EnablePalmaBoostMode(u64 aruid, bool is_enabled); + + Result RegisterCoreAppletResource(); + Result UnregisterCoreAppletResource(); + +private: + static constexpr std::size_t AruidIndexMax = 0x20; + + enum RegistrationStatus : u32 { + None, + Initialized, + PendingDelete, + }; + + struct DataStatusFlag { + union { + u32 raw{}; + + BitField<0, 1, u32> is_initialized; + BitField<1, 1, u32> is_assigned; + BitField<16, 1, u32> enable_pad_input; + BitField<17, 1, u32> enable_six_axis_sensor; + BitField<18, 1, u32> bit_18; + BitField<19, 1, u32> is_palma_connectable; + BitField<20, 1, u32> enable_palma_boost_mode; + BitField<21, 1, u32> enable_touchscreen; + }; + }; + + struct AruidRegisterList { + std::array<RegistrationStatus, AruidIndexMax> flag{}; + std::array<u64, AruidIndexMax> aruid{}; + }; + static_assert(sizeof(AruidRegisterList) == 0x180, "AruidRegisterList is an invalid size"); + + struct AruidData { + DataStatusFlag flag{}; + u64 aruid{}; + SharedMemoryFormat* shared_memory_format{nullptr}; + }; + + u64 active_aruid{}; + AruidRegisterList registration_list{}; + std::array<AruidData, AruidIndexMax> data{}; + std::array<SharedMemoryHolder, AruidIndexMax> shared_memory_holder{}; + s32 ref_counter{}; + + Core::System& system; +}; +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/console_six_axis.cpp b/src/core/hle/service/hid/controllers/console_six_axis.cpp index b2bf1d78d..3961d2b5f 100644 --- a/src/core/hle/service/hid/controllers/console_six_axis.cpp +++ b/src/core/hle/service/hid/controllers/console_six_axis.cpp @@ -1,23 +1,18 @@ // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include "core/core.h" #include "core/core_timing.h" #include "core/hid/emulated_console.h" #include "core/hid/hid_core.h" #include "core/hle/service/hid/controllers/console_six_axis.h" -#include "core/memory.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" namespace Service::HID { -constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C200; -ConsoleSixAxis::ConsoleSixAxis(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) - : ControllerBase{hid_core_} { +ConsoleSixAxis::ConsoleSixAxis(Core::HID::HIDCore& hid_core_, + ConsoleSixAxisSensorSharedMemoryFormat& console_shared_memory) + : ControllerBase{hid_core_}, shared_memory{console_shared_memory} { console = hid_core.GetEmulatedConsole(); - static_assert(SHARED_MEMORY_OFFSET + sizeof(ConsoleSharedMemory) < shared_memory_size, - "ConsoleSharedMemory is bigger than the shared memory"); - shared_memory = std::construct_at( - reinterpret_cast<ConsoleSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); } ConsoleSixAxis::~ConsoleSixAxis() = default; @@ -33,10 +28,10 @@ void ConsoleSixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) { const auto motion_status = console->GetMotion(); - shared_memory->sampling_number++; - shared_memory->is_seven_six_axis_sensor_at_rest = motion_status.is_at_rest; - shared_memory->verticalization_error = motion_status.verticalization_error; - shared_memory->gyro_bias = motion_status.gyro_bias; + shared_memory.sampling_number++; + shared_memory.is_seven_six_axis_sensor_at_rest = motion_status.is_at_rest; + shared_memory.verticalization_error = motion_status.verticalization_error; + shared_memory.gyro_bias = motion_status.gyro_bias; } } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/console_six_axis.h b/src/core/hle/service/hid/controllers/console_six_axis.h index 5b7c6a29a..3d1c9ce23 100644 --- a/src/core/hle/service/hid/controllers/console_six_axis.h +++ b/src/core/hle/service/hid/controllers/console_six_axis.h @@ -3,7 +3,6 @@ #pragma once -#include "common/vector_math.h" #include "core/hle/service/hid/controllers/controller_base.h" namespace Core::HID { @@ -11,9 +10,12 @@ class EmulatedConsole; } // namespace Core::HID namespace Service::HID { +struct ConsoleSixAxisSensorSharedMemoryFormat; + class ConsoleSixAxis final : public ControllerBase { public: - explicit ConsoleSixAxis(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); + explicit ConsoleSixAxis(Core::HID::HIDCore& hid_core_, + ConsoleSixAxisSensorSharedMemoryFormat& console_shared_memory); ~ConsoleSixAxis() override; // Called when the controller is initialized @@ -26,18 +28,7 @@ public: void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; private: - // This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat - struct ConsoleSharedMemory { - u64 sampling_number{}; - bool is_seven_six_axis_sensor_at_rest{}; - INSERT_PADDING_BYTES(3); // padding - f32 verticalization_error{}; - Common::Vec3f gyro_bias{}; - INSERT_PADDING_BYTES(4); // padding - }; - static_assert(sizeof(ConsoleSharedMemory) == 0x20, "ConsoleSharedMemory is an invalid size"); - - ConsoleSharedMemory* shared_memory = nullptr; + ConsoleSixAxisSensorSharedMemoryFormat& shared_memory; Core::HID::EmulatedConsole* console = nullptr; }; } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/controller_base.h b/src/core/hle/service/hid/controllers/controller_base.h index 9a44ee41e..4326c7821 100644 --- a/src/core/hle/service/hid/controllers/controller_base.h +++ b/src/core/hle/service/hid/controllers/controller_base.h @@ -39,9 +39,6 @@ public: bool IsControllerActivated() const; - static const std::size_t hid_entry_count = 17; - static const std::size_t shared_memory_size = 0x40000; - protected: bool is_activated{false}; diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp index 9de19ebfc..7d2370b4f 100644 --- a/src/core/hle/service/hid/controllers/debug_pad.cpp +++ b/src/core/hle/service/hid/controllers/debug_pad.cpp @@ -1,24 +1,19 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <cstring> -#include "common/common_types.h" #include "common/settings.h" #include "core/core_timing.h" #include "core/hid/emulated_controller.h" #include "core/hid/hid_core.h" #include "core/hid/hid_types.h" #include "core/hle/service/hid/controllers/debug_pad.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" namespace Service::HID { -constexpr std::size_t SHARED_MEMORY_OFFSET = 0x00000; - -DebugPad::DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) - : ControllerBase{hid_core_} { - static_assert(SHARED_MEMORY_OFFSET + sizeof(DebugPadSharedMemory) < shared_memory_size, - "DebugPadSharedMemory is bigger than the shared memory"); - shared_memory = std::construct_at( - reinterpret_cast<DebugPadSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); + +DebugPad::DebugPad(Core::HID::HIDCore& hid_core_, + DebugPadSharedMemoryFormat& debug_pad_shared_memory) + : ControllerBase{hid_core_}, shared_memory{debug_pad_shared_memory} { controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other); } @@ -30,12 +25,12 @@ void DebugPad::OnRelease() {} void DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) { if (!IsControllerActivated()) { - shared_memory->debug_pad_lifo.buffer_count = 0; - shared_memory->debug_pad_lifo.buffer_tail = 0; + shared_memory.debug_pad_lifo.buffer_count = 0; + shared_memory.debug_pad_lifo.buffer_tail = 0; return; } - const auto& last_entry = shared_memory->debug_pad_lifo.ReadCurrentEntry().state; + const auto& last_entry = shared_memory.debug_pad_lifo.ReadCurrentEntry().state; next_state.sampling_number = last_entry.sampling_number + 1; if (Settings::values.debug_pad_enabled) { @@ -49,7 +44,7 @@ void DebugPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) { next_state.r_stick = stick_state.right; } - shared_memory->debug_pad_lifo.WriteNextEntry(next_state); + shared_memory.debug_pad_lifo.WriteNextEntry(next_state); } } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/debug_pad.h b/src/core/hle/service/hid/controllers/debug_pad.h index 5566dba77..8ab29eca8 100644 --- a/src/core/hle/service/hid/controllers/debug_pad.h +++ b/src/core/hle/service/hid/controllers/debug_pad.h @@ -3,21 +3,24 @@ #pragma once -#include "common/bit_field.h" -#include "common/common_types.h" #include "core/hle/service/hid/controllers/controller_base.h" -#include "core/hle/service/hid/ring_lifo.h" +#include "core/hle/service/hid/controllers/types/debug_pad_types.h" namespace Core::HID { -class EmulatedController; -struct DebugPadButton; -struct AnalogStickState; -} // namespace Core::HID +class HIDCore; +} + +namespace Core::Timing { +class CoreTiming; +} namespace Service::HID { +struct DebugPadSharedMemoryFormat; + class DebugPad final : public ControllerBase { public: - explicit DebugPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); + explicit DebugPad(Core::HID::HIDCore& hid_core_, + DebugPadSharedMemoryFormat& debug_pad_shared_memory); ~DebugPad() override; // Called when the controller is initialized @@ -30,35 +33,8 @@ public: void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; private: - // This is nn::hid::DebugPadAttribute - struct DebugPadAttribute { - union { - u32 raw{}; - BitField<0, 1, u32> connected; - }; - }; - static_assert(sizeof(DebugPadAttribute) == 0x4, "DebugPadAttribute is an invalid size"); - - // This is nn::hid::DebugPadState - struct DebugPadState { - s64 sampling_number{}; - DebugPadAttribute attribute{}; - Core::HID::DebugPadButton pad_state{}; - Core::HID::AnalogStickState r_stick{}; - Core::HID::AnalogStickState l_stick{}; - }; - static_assert(sizeof(DebugPadState) == 0x20, "DebugPadState is an invalid state"); - - struct DebugPadSharedMemory { - // This is nn::hid::detail::DebugPadLifo - Lifo<DebugPadState, hid_entry_count> debug_pad_lifo{}; - static_assert(sizeof(debug_pad_lifo) == 0x2C8, "debug_pad_lifo is an invalid size"); - INSERT_PADDING_WORDS(0x4E); - }; - static_assert(sizeof(DebugPadSharedMemory) == 0x400, "DebugPadSharedMemory is an invalid size"); - DebugPadState next_state{}; - DebugPadSharedMemory* shared_memory = nullptr; + DebugPadSharedMemoryFormat& shared_memory; Core::HID::EmulatedController* controller = nullptr; }; } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/gesture.cpp b/src/core/hle/service/hid/controllers/gesture.cpp index 59b2ec73c..f658005f6 100644 --- a/src/core/hle/service/hid/controllers/gesture.cpp +++ b/src/core/hle/service/hid/controllers/gesture.cpp @@ -1,17 +1,15 @@ // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include "common/logging/log.h" #include "common/math_util.h" #include "common/settings.h" -#include "core/core_timing.h" #include "core/frontend/emu_window.h" +#include "core/hid/emulated_console.h" #include "core/hid/hid_core.h" #include "core/hle/service/hid/controllers/gesture.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" namespace Service::HID { -constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3BA00; - // HW is around 700, value is set to 400 to make it easier to trigger with mouse constexpr f32 swipe_threshold = 400.0f; // Threshold in pixels/s constexpr f32 angle_threshold = 0.015f; // Threshold in radians @@ -23,19 +21,15 @@ constexpr f32 Square(s32 num) { return static_cast<f32>(num * num); } -Gesture::Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) - : ControllerBase(hid_core_) { - static_assert(SHARED_MEMORY_OFFSET + sizeof(GestureSharedMemory) < shared_memory_size, - "GestureSharedMemory is bigger than the shared memory"); - shared_memory = std::construct_at( - reinterpret_cast<GestureSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); +Gesture::Gesture(Core::HID::HIDCore& hid_core_, GestureSharedMemoryFormat& gesture_shared_memory) + : ControllerBase(hid_core_), shared_memory{gesture_shared_memory} { console = hid_core.GetEmulatedConsole(); } Gesture::~Gesture() = default; void Gesture::OnInit() { - shared_memory->gesture_lifo.buffer_count = 0; - shared_memory->gesture_lifo.buffer_tail = 0; + shared_memory.gesture_lifo.buffer_count = 0; + shared_memory.gesture_lifo.buffer_tail = 0; force_update = true; } @@ -43,8 +37,8 @@ void Gesture::OnRelease() {} void Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) { if (!IsControllerActivated()) { - shared_memory->gesture_lifo.buffer_count = 0; - shared_memory->gesture_lifo.buffer_tail = 0; + shared_memory.gesture_lifo.buffer_count = 0; + shared_memory.gesture_lifo.buffer_tail = 0; return; } @@ -52,7 +46,7 @@ void Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) { GestureProperties gesture = GetGestureProperties(); f32 time_difference = - static_cast<f32>(shared_memory->gesture_lifo.timestamp - last_update_timestamp) / + static_cast<f32>(shared_memory.gesture_lifo.timestamp - last_update_timestamp) / (1000 * 1000 * 1000); // Only update if necessary @@ -60,7 +54,7 @@ void Gesture::OnUpdate(const Core::Timing::CoreTiming& core_timing) { return; } - last_update_timestamp = shared_memory->gesture_lifo.timestamp; + last_update_timestamp = shared_memory.gesture_lifo.timestamp; UpdateGestureSharedMemory(gesture, time_difference); } @@ -103,7 +97,7 @@ void Gesture::UpdateGestureSharedMemory(GestureProperties& gesture, f32 time_dif GestureType type = GestureType::Idle; GestureAttribute attributes{}; - const auto& last_entry = shared_memory->gesture_lifo.ReadCurrentEntry().state; + const auto& last_entry = shared_memory.gesture_lifo.ReadCurrentEntry().state; // Reset next state to default next_state.sampling_number = last_entry.sampling_number + 1; @@ -133,7 +127,7 @@ void Gesture::UpdateGestureSharedMemory(GestureProperties& gesture, f32 time_dif next_state.points = gesture.points; last_gesture = gesture; - shared_memory->gesture_lifo.WriteNextEntry(next_state); + shared_memory.gesture_lifo.WriteNextEntry(next_state); } void Gesture::NewGesture(GestureProperties& gesture, GestureType& type, @@ -305,11 +299,11 @@ void Gesture::SetSwipeEvent(GestureProperties& gesture, GestureProperties& last_ next_state.direction = GestureDirection::Up; } -const Gesture::GestureState& Gesture::GetLastGestureEntry() const { - return shared_memory->gesture_lifo.ReadCurrentEntry().state; +const GestureState& Gesture::GetLastGestureEntry() const { + return shared_memory.gesture_lifo.ReadCurrentEntry().state; } -Gesture::GestureProperties Gesture::GetGestureProperties() { +GestureProperties Gesture::GetGestureProperties() { GestureProperties gesture; std::array<Core::HID::TouchFinger, MAX_POINTS> active_fingers; const auto end_iter = std::copy_if(fingers.begin(), fingers.end(), active_fingers.begin(), diff --git a/src/core/hle/service/hid/controllers/gesture.h b/src/core/hle/service/hid/controllers/gesture.h index 4c6f8ee07..41fdfcd03 100644 --- a/src/core/hle/service/hid/controllers/gesture.h +++ b/src/core/hle/service/hid/controllers/gesture.h @@ -4,17 +4,22 @@ #pragma once #include <array> -#include "common/bit_field.h" + #include "common/common_types.h" -#include "common/point.h" -#include "core/hid/emulated_console.h" #include "core/hle/service/hid/controllers/controller_base.h" -#include "core/hle/service/hid/ring_lifo.h" +#include "core/hle/service/hid/controllers/types/touch_types.h" + +namespace Core::HID { +class EmulatedConsole; +} namespace Service::HID { +struct GestureSharedMemoryFormat; + class Gesture final : public ControllerBase { public: - explicit Gesture(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); + explicit Gesture(Core::HID::HIDCore& hid_core_, + GestureSharedMemoryFormat& gesture_shared_memory); ~Gesture() override; // Called when the controller is initialized @@ -27,79 +32,6 @@ public: void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; private: - static constexpr size_t MAX_FINGERS = 16; - static constexpr size_t MAX_POINTS = 4; - - // This is nn::hid::GestureType - enum class GestureType : u32 { - Idle, // Nothing touching the screen - Complete, // Set at the end of a touch event - Cancel, // Set when the number of fingers change - Touch, // A finger just touched the screen - Press, // Set if last type is touch and the finger hasn't moved - Tap, // Fast press then release - Pan, // All points moving together across the screen - Swipe, // Fast press movement and release of a single point - Pinch, // All points moving away/closer to the midpoint - Rotate, // All points rotating from the midpoint - }; - - // This is nn::hid::GestureDirection - enum class GestureDirection : u32 { - None, - Left, - Up, - Right, - Down, - }; - - // This is nn::hid::GestureAttribute - struct GestureAttribute { - union { - u32 raw{}; - - BitField<4, 1, u32> is_new_touch; - BitField<8, 1, u32> is_double_tap; - }; - }; - static_assert(sizeof(GestureAttribute) == 4, "GestureAttribute is an invalid size"); - - // This is nn::hid::GestureState - struct GestureState { - s64 sampling_number{}; - s64 detection_count{}; - GestureType type{GestureType::Idle}; - GestureDirection direction{GestureDirection::None}; - Common::Point<s32> pos{}; - Common::Point<s32> delta{}; - f32 vel_x{}; - f32 vel_y{}; - GestureAttribute attributes{}; - f32 scale{}; - f32 rotation_angle{}; - s32 point_count{}; - std::array<Common::Point<s32>, 4> points{}; - }; - static_assert(sizeof(GestureState) == 0x60, "GestureState is an invalid size"); - - struct GestureProperties { - std::array<Common::Point<s32>, MAX_POINTS> points{}; - std::size_t active_points{}; - Common::Point<s32> mid_point{}; - s64 detection_count{}; - u64 delta_time{}; - f32 average_distance{}; - f32 angle{}; - }; - - struct GestureSharedMemory { - // This is nn::hid::detail::GestureLifo - Lifo<GestureState, hid_entry_count> gesture_lifo{}; - static_assert(sizeof(gesture_lifo) == 0x708, "gesture_lifo is an invalid size"); - INSERT_PADDING_WORDS(0x3E); - }; - static_assert(sizeof(GestureSharedMemory) == 0x800, "GestureSharedMemory is an invalid size"); - // Reads input from all available input engines void ReadTouchInput(); @@ -142,7 +74,7 @@ private: GestureProperties GetGestureProperties(); GestureState next_state{}; - GestureSharedMemory* shared_memory = nullptr; + GestureSharedMemoryFormat& shared_memory; Core::HID::EmulatedConsole* console = nullptr; std::array<Core::HID::TouchFinger, MAX_POINTS> fingers{}; diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp index ddb1b0ba4..871e5036a 100644 --- a/src/core/hle/service/hid/controllers/keyboard.cpp +++ b/src/core/hle/service/hid/controllers/keyboard.cpp @@ -1,23 +1,18 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <cstring> -#include "common/common_types.h" #include "common/settings.h" #include "core/core_timing.h" #include "core/hid/emulated_devices.h" #include "core/hid/hid_core.h" #include "core/hle/service/hid/controllers/keyboard.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" namespace Service::HID { -constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800; - -Keyboard::Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) - : ControllerBase{hid_core_} { - static_assert(SHARED_MEMORY_OFFSET + sizeof(KeyboardSharedMemory) < shared_memory_size, - "KeyboardSharedMemory is bigger than the shared memory"); - shared_memory = std::construct_at( - reinterpret_cast<KeyboardSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); + +Keyboard::Keyboard(Core::HID::HIDCore& hid_core_, + KeyboardSharedMemoryFormat& keyboard_shared_memory) + : ControllerBase{hid_core_}, shared_memory{keyboard_shared_memory} { emulated_devices = hid_core.GetEmulatedDevices(); } @@ -29,12 +24,12 @@ void Keyboard::OnRelease() {} void Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing) { if (!IsControllerActivated()) { - shared_memory->keyboard_lifo.buffer_count = 0; - shared_memory->keyboard_lifo.buffer_tail = 0; + shared_memory.keyboard_lifo.buffer_count = 0; + shared_memory.keyboard_lifo.buffer_tail = 0; return; } - const auto& last_entry = shared_memory->keyboard_lifo.ReadCurrentEntry().state; + const auto& last_entry = shared_memory.keyboard_lifo.ReadCurrentEntry().state; next_state.sampling_number = last_entry.sampling_number + 1; if (Settings::values.keyboard_enabled) { @@ -46,7 +41,7 @@ void Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing) { next_state.attribute.is_connected.Assign(1); } - shared_memory->keyboard_lifo.WriteNextEntry(next_state); + shared_memory.keyboard_lifo.WriteNextEntry(next_state); } } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/keyboard.h b/src/core/hle/service/hid/controllers/keyboard.h index 172ec1309..4d72171b9 100644 --- a/src/core/hle/service/hid/controllers/keyboard.h +++ b/src/core/hle/service/hid/controllers/keyboard.h @@ -3,20 +3,16 @@ #pragma once -#include "common/common_types.h" #include "core/hle/service/hid/controllers/controller_base.h" -#include "core/hle/service/hid/ring_lifo.h" - -namespace Core::HID { -class EmulatedDevices; -struct KeyboardModifier; -struct KeyboardKey; -} // namespace Core::HID +#include "core/hle/service/hid/controllers/types/keyboard_types.h" namespace Service::HID { +struct KeyboardSharedMemoryFormat; + class Keyboard final : public ControllerBase { public: - explicit Keyboard(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); + explicit Keyboard(Core::HID::HIDCore& hid_core_, + KeyboardSharedMemoryFormat& keyboard_shared_memory); ~Keyboard() override; // Called when the controller is initialized @@ -29,25 +25,8 @@ public: void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; private: - // This is nn::hid::detail::KeyboardState - struct KeyboardState { - s64 sampling_number{}; - Core::HID::KeyboardModifier modifier{}; - Core::HID::KeyboardAttribute attribute{}; - Core::HID::KeyboardKey key{}; - }; - static_assert(sizeof(KeyboardState) == 0x30, "KeyboardState is an invalid size"); - - struct KeyboardSharedMemory { - // This is nn::hid::detail::KeyboardLifo - Lifo<KeyboardState, hid_entry_count> keyboard_lifo{}; - static_assert(sizeof(keyboard_lifo) == 0x3D8, "keyboard_lifo is an invalid size"); - INSERT_PADDING_WORDS(0xA); - }; - static_assert(sizeof(KeyboardSharedMemory) == 0x400, "KeyboardSharedMemory is an invalid size"); - KeyboardState next_state{}; - KeyboardSharedMemory* shared_memory = nullptr; + KeyboardSharedMemoryFormat& shared_memory; Core::HID::EmulatedDevices* emulated_devices = nullptr; }; } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/mouse.cpp b/src/core/hle/service/hid/controllers/mouse.cpp index 6e5a04e34..de5b2c804 100644 --- a/src/core/hle/service/hid/controllers/mouse.cpp +++ b/src/core/hle/service/hid/controllers/mouse.cpp @@ -1,22 +1,17 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <cstring> -#include "common/common_types.h" #include "core/core_timing.h" #include "core/frontend/emu_window.h" #include "core/hid/emulated_devices.h" #include "core/hid/hid_core.h" #include "core/hle/service/hid/controllers/mouse.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" namespace Service::HID { -constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400; -Mouse::Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) : ControllerBase{hid_core_} { - static_assert(SHARED_MEMORY_OFFSET + sizeof(MouseSharedMemory) < shared_memory_size, - "MouseSharedMemory is bigger than the shared memory"); - shared_memory = std::construct_at( - reinterpret_cast<MouseSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); +Mouse::Mouse(Core::HID::HIDCore& hid_core_, MouseSharedMemoryFormat& mouse_shared_memory) + : ControllerBase{hid_core_}, shared_memory{mouse_shared_memory} { emulated_devices = hid_core.GetEmulatedDevices(); } @@ -27,14 +22,14 @@ void Mouse::OnRelease() {} void Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing) { if (!IsControllerActivated()) { - shared_memory->mouse_lifo.buffer_count = 0; - shared_memory->mouse_lifo.buffer_tail = 0; + shared_memory.mouse_lifo.buffer_count = 0; + shared_memory.mouse_lifo.buffer_tail = 0; return; } next_state = {}; - const auto& last_entry = shared_memory->mouse_lifo.ReadCurrentEntry().state; + const auto& last_entry = shared_memory.mouse_lifo.ReadCurrentEntry().state; next_state.sampling_number = last_entry.sampling_number + 1; if (Settings::values.mouse_enabled) { @@ -53,7 +48,7 @@ void Mouse::OnUpdate(const Core::Timing::CoreTiming& core_timing) { next_state.button = mouse_button_state; } - shared_memory->mouse_lifo.WriteNextEntry(next_state); + shared_memory.mouse_lifo.WriteNextEntry(next_state); } } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/mouse.h b/src/core/hle/service/hid/controllers/mouse.h index a80f3823f..363f316a5 100644 --- a/src/core/hle/service/hid/controllers/mouse.h +++ b/src/core/hle/service/hid/controllers/mouse.h @@ -3,9 +3,7 @@ #pragma once -#include "common/common_types.h" #include "core/hle/service/hid/controllers/controller_base.h" -#include "core/hle/service/hid/ring_lifo.h" namespace Core::HID { class EmulatedDevices; @@ -14,9 +12,11 @@ struct AnalogStickState; } // namespace Core::HID namespace Service::HID { +struct MouseSharedMemoryFormat; + class Mouse final : public ControllerBase { public: - explicit Mouse(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); + explicit Mouse(Core::HID::HIDCore& hid_core_, MouseSharedMemoryFormat& mouse_shared_memory); ~Mouse() override; // Called when the controller is initialized @@ -29,17 +29,9 @@ public: void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; private: - struct MouseSharedMemory { - // This is nn::hid::detail::MouseLifo - Lifo<Core::HID::MouseState, hid_entry_count> mouse_lifo{}; - static_assert(sizeof(mouse_lifo) == 0x350, "mouse_lifo is an invalid size"); - INSERT_PADDING_WORDS(0x2C); - }; - static_assert(sizeof(MouseSharedMemory) == 0x400, "MouseSharedMemory is an invalid size"); - Core::HID::MouseState next_state{}; Core::HID::AnalogStickState last_mouse_wheel_state{}; - MouseSharedMemory* shared_memory = nullptr; + MouseSharedMemoryFormat& shared_memory; Core::HID::EmulatedDevices* emulated_devices = nullptr; }; } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp index 08ee9de9c..53a737cf5 100644 --- a/src/core/hle/service/hid/controllers/npad.cpp +++ b/src/core/hle/service/hid/controllers/npad.cpp @@ -17,12 +17,12 @@ #include "core/hle/kernel/k_event.h" #include "core/hle/kernel/k_readable_event.h" #include "core/hle/service/hid/controllers/npad.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" #include "core/hle/service/hid/errors.h" #include "core/hle/service/hid/hid_util.h" #include "core/hle/service/kernel_helpers.h" namespace Service::HID { -constexpr std::size_t NPAD_OFFSET = 0x9A00; constexpr std::array<Core::HID::NpadIdType, 10> npad_id_list{ Core::HID::NpadIdType::Player1, Core::HID::NpadIdType::Player2, Core::HID::NpadIdType::Player3, Core::HID::NpadIdType::Player4, Core::HID::NpadIdType::Player5, Core::HID::NpadIdType::Player6, @@ -30,14 +30,12 @@ constexpr std::array<Core::HID::NpadIdType, 10> npad_id_list{ Core::HID::NpadIdType::Handheld, }; -NPad::NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_, +NPad::NPad(Core::HID::HIDCore& hid_core_, NpadSharedMemoryFormat& npad_shared_memory_format, KernelHelpers::ServiceContext& service_context_) : ControllerBase{hid_core_}, service_context{service_context_} { - static_assert(NPAD_OFFSET + (NPAD_COUNT * sizeof(NpadInternalState)) < shared_memory_size); for (std::size_t i = 0; i < controller_data.size(); ++i) { auto& controller = controller_data[i]; - controller.shared_memory = std::construct_at(reinterpret_cast<NpadInternalState*>( - raw_shared_memory_ + NPAD_OFFSET + (i * sizeof(NpadInternalState)))); + controller.shared_memory = &npad_shared_memory_format.npad_entry[i].internal_state; controller.device = hid_core.GetEmulatedControllerByIndex(i); controller.vibration[Core::HID::EmulatedDeviceIndex::LeftIndex].latest_vibration_value = Core::HID::DEFAULT_VIBRATION_VALUE; @@ -617,7 +615,7 @@ void NPad::SetHoldType(NpadJoyHoldType joy_hold_type) { hold_type = joy_hold_type; } -NPad::NpadJoyHoldType NPad::GetHoldType() const { +NpadJoyHoldType NPad::GetHoldType() const { return hold_type; } @@ -630,7 +628,7 @@ void NPad::SetNpadHandheldActivationMode(NpadHandheldActivationMode activation_m handheld_activation_mode = activation_mode; } -NPad::NpadHandheldActivationMode NPad::GetNpadHandheldActivationMode() const { +NpadHandheldActivationMode NPad::GetNpadHandheldActivationMode() const { return handheld_activation_mode; } @@ -638,7 +636,7 @@ void NPad::SetNpadCommunicationMode(NpadCommunicationMode communication_mode_) { communication_mode = communication_mode_; } -NPad::NpadCommunicationMode NPad::GetNpadCommunicationMode() const { +NpadCommunicationMode NPad::GetNpadCommunicationMode() const { return communication_mode; } @@ -978,27 +976,27 @@ Result NPad::ResetIsSixAxisSensorDeviceNewlyAssigned( return ResultSuccess; } -NPad::SixAxisLifo& NPad::GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id) { +NpadSixAxisSensorLifo& NPad::GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id) { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_fullkey_lifo; } -NPad::SixAxisLifo& NPad::GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id) { +NpadSixAxisSensorLifo& NPad::GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id) { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_handheld_lifo; } -NPad::SixAxisLifo& NPad::GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id) { +NpadSixAxisSensorLifo& NPad::GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id) { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_dual_left_lifo; } -NPad::SixAxisLifo& NPad::GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id) { +NpadSixAxisSensorLifo& NPad::GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id) { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_dual_right_lifo; } -NPad::SixAxisLifo& NPad::GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id) { +NpadSixAxisSensorLifo& NPad::GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id) { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_left_lifo; } -NPad::SixAxisLifo& NPad::GetSixAxisRightLifo(Core::HID::NpadIdType npad_id) { +NpadSixAxisSensorLifo& NPad::GetSixAxisRightLifo(Core::HID::NpadIdType npad_id) { return GetControllerFromNpadIdType(npad_id).shared_memory->sixaxis_right_lifo; } @@ -1343,7 +1341,7 @@ const Core::HID::SixAxisSensorProperties& NPad::GetSixaxisProperties( } } -NPad::AppletDetailedUiType NPad::GetAppletDetailedUiType(Core::HID::NpadIdType npad_id) { +AppletDetailedUiType NPad::GetAppletDetailedUiType(Core::HID::NpadIdType npad_id) { const auto& shared_memory = GetControllerFromNpadIdType(npad_id).shared_memory; return { diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h index 9167c93f0..4e2412356 100644 --- a/src/core/hle/service/hid/controllers/npad.h +++ b/src/core/hle/service/hid/controllers/npad.h @@ -8,12 +8,10 @@ #include <mutex> #include <span> -#include "common/bit_field.h" #include "common/common_types.h" - #include "core/hid/hid_types.h" #include "core/hle/service/hid/controllers/controller_base.h" -#include "core/hle/service/hid/ring_lifo.h" +#include "core/hle/service/hid/controllers/types/npad_types.h" namespace Core::HID { class EmulatedController; @@ -32,10 +30,13 @@ class ServiceContext; union Result; namespace Service::HID { +struct NpadInternalState; +struct NpadSixAxisSensorLifo; +struct NpadSharedMemoryFormat; class NPad final : public ControllerBase { public: - explicit NPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_, + explicit NPad(Core::HID::HIDCore& hid_core_, NpadSharedMemoryFormat& npad_shared_memory_format, KernelHelpers::ServiceContext& service_context_); ~NPad() override; @@ -48,89 +49,6 @@ public: // When the controller is requesting an update for the shared memory void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; - // This is nn::hid::NpadJoyHoldType - enum class NpadJoyHoldType : u64 { - Vertical = 0, - Horizontal = 1, - }; - - // This is nn::hid::NpadJoyAssignmentMode - enum class NpadJoyAssignmentMode : u32 { - Dual = 0, - Single = 1, - }; - - // This is nn::hid::NpadJoyDeviceType - enum class NpadJoyDeviceType : s64 { - Left = 0, - Right = 1, - }; - - // This is nn::hid::NpadHandheldActivationMode - enum class NpadHandheldActivationMode : u64 { - Dual = 0, - Single = 1, - None = 2, - MaxActivationMode = 3, - }; - - // This is nn::hid::system::AppletFooterUiAttributesSet - struct AppletFooterUiAttributes { - INSERT_PADDING_BYTES(0x4); - }; - - // This is nn::hid::system::AppletFooterUiType - enum class AppletFooterUiType : u8 { - None = 0, - HandheldNone = 1, - HandheldJoyConLeftOnly = 2, - HandheldJoyConRightOnly = 3, - HandheldJoyConLeftJoyConRight = 4, - JoyDual = 5, - JoyDualLeftOnly = 6, - JoyDualRightOnly = 7, - JoyLeftHorizontal = 8, - JoyLeftVertical = 9, - JoyRightHorizontal = 10, - JoyRightVertical = 11, - SwitchProController = 12, - CompatibleProController = 13, - CompatibleJoyCon = 14, - LarkHvc1 = 15, - LarkHvc2 = 16, - LarkNesLeft = 17, - LarkNesRight = 18, - Lucia = 19, - Verification = 20, - Lagon = 21, - }; - - using AppletFooterUiVariant = u8; - - // This is "nn::hid::system::AppletDetailedUiType". - struct AppletDetailedUiType { - AppletFooterUiVariant ui_variant; - INSERT_PADDING_BYTES(0x2); - AppletFooterUiType footer; - }; - static_assert(sizeof(AppletDetailedUiType) == 0x4, "AppletDetailedUiType is an invalid size"); - // This is nn::hid::NpadCommunicationMode - enum class NpadCommunicationMode : u64 { - Mode_5ms = 0, - Mode_10ms = 1, - Mode_15ms = 2, - Default = 3, - }; - - enum class NpadRevision : u32 { - Revision0 = 0, - Revision1 = 1, - Revision2 = 2, - Revision3 = 3, - }; - - using SixAxisLifo = Lifo<Core::HID::SixAxisSensorState, hid_entry_count>; - void SetSupportedStyleSet(Core::HID::NpadStyleTag style_set); Core::HID::NpadStyleTag GetSupportedStyleSet() const; @@ -188,12 +106,12 @@ public: Result ResetIsSixAxisSensorDeviceNewlyAssigned( const Core::HID::SixAxisSensorHandle& sixaxis_handle); - SixAxisLifo& GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id); - SixAxisLifo& GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id); - SixAxisLifo& GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id); - SixAxisLifo& GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id); - SixAxisLifo& GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id); - SixAxisLifo& GetSixAxisRightLifo(Core::HID::NpadIdType npad_id); + NpadSixAxisSensorLifo& GetSixAxisFullkeyLifo(Core::HID::NpadIdType npad_id); + NpadSixAxisSensorLifo& GetSixAxisHandheldLifo(Core::HID::NpadIdType npad_id); + NpadSixAxisSensorLifo& GetSixAxisDualLeftLifo(Core::HID::NpadIdType npad_id); + NpadSixAxisSensorLifo& GetSixAxisDualRightLifo(Core::HID::NpadIdType npad_id); + NpadSixAxisSensorLifo& GetSixAxisLeftLifo(Core::HID::NpadIdType npad_id); + NpadSixAxisSensorLifo& GetSixAxisRightLifo(Core::HID::NpadIdType npad_id); Result GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const; Result IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id, @@ -221,214 +139,6 @@ public: AppletDetailedUiType GetAppletDetailedUiType(Core::HID::NpadIdType npad_id); private: - static constexpr std::size_t NPAD_COUNT = 10; - - // This is nn::hid::detail::ColorAttribute - enum class ColorAttribute : u32 { - Ok = 0, - ReadError = 1, - NoController = 2, - }; - static_assert(sizeof(ColorAttribute) == 4, "ColorAttribute is an invalid size"); - - // This is nn::hid::detail::NpadFullKeyColorState - struct NpadFullKeyColorState { - ColorAttribute attribute{ColorAttribute::NoController}; - Core::HID::NpadControllerColor fullkey{}; - }; - static_assert(sizeof(NpadFullKeyColorState) == 0xC, "NpadFullKeyColorState is an invalid size"); - - // This is nn::hid::detail::NpadJoyColorState - struct NpadJoyColorState { - ColorAttribute attribute{ColorAttribute::NoController}; - Core::HID::NpadControllerColor left{}; - Core::HID::NpadControllerColor right{}; - }; - static_assert(sizeof(NpadJoyColorState) == 0x14, "NpadJoyColorState is an invalid size"); - - // This is nn::hid::NpadAttribute - struct NpadAttribute { - union { - u32 raw{}; - BitField<0, 1, u32> is_connected; - BitField<1, 1, u32> is_wired; - BitField<2, 1, u32> is_left_connected; - BitField<3, 1, u32> is_left_wired; - BitField<4, 1, u32> is_right_connected; - BitField<5, 1, u32> is_right_wired; - }; - }; - static_assert(sizeof(NpadAttribute) == 4, "NpadAttribute is an invalid size"); - - // This is nn::hid::NpadFullKeyState - // This is nn::hid::NpadHandheldState - // This is nn::hid::NpadJoyDualState - // This is nn::hid::NpadJoyLeftState - // This is nn::hid::NpadJoyRightState - // This is nn::hid::NpadPalmaState - // This is nn::hid::NpadSystemExtState - struct NPadGenericState { - s64_le sampling_number{}; - Core::HID::NpadButtonState npad_buttons{}; - Core::HID::AnalogStickState l_stick{}; - Core::HID::AnalogStickState r_stick{}; - NpadAttribute connection_status{}; - INSERT_PADDING_BYTES(4); // Reserved - }; - static_assert(sizeof(NPadGenericState) == 0x28, "NPadGenericState is an invalid size"); - - // This is nn::hid::server::NpadGcTriggerState - struct NpadGcTriggerState { - s64 sampling_number{}; - s32 l_analog{}; - s32 r_analog{}; - }; - static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size"); - - // This is nn::hid::NpadSystemProperties - struct NPadSystemProperties { - union { - s64 raw{}; - BitField<0, 1, s64> is_charging_joy_dual; - BitField<1, 1, s64> is_charging_joy_left; - BitField<2, 1, s64> is_charging_joy_right; - BitField<3, 1, s64> is_powered_joy_dual; - BitField<4, 1, s64> is_powered_joy_left; - BitField<5, 1, s64> is_powered_joy_right; - BitField<9, 1, s64> is_system_unsupported_button; - BitField<10, 1, s64> is_system_ext_unsupported_button; - BitField<11, 1, s64> is_vertical; - BitField<12, 1, s64> is_horizontal; - BitField<13, 1, s64> use_plus; - BitField<14, 1, s64> use_minus; - BitField<15, 1, s64> use_directional_buttons; - }; - }; - static_assert(sizeof(NPadSystemProperties) == 0x8, "NPadSystemProperties is an invalid size"); - - // This is nn::hid::NpadSystemButtonProperties - struct NpadSystemButtonProperties { - union { - s32 raw{}; - BitField<0, 1, s32> is_home_button_protection_enabled; - }; - }; - static_assert(sizeof(NpadSystemButtonProperties) == 0x4, - "NPadButtonProperties is an invalid size"); - - // This is nn::hid::system::DeviceType - struct DeviceType { - union { - u32 raw{}; - BitField<0, 1, s32> fullkey; - BitField<1, 1, s32> debug_pad; - BitField<2, 1, s32> handheld_left; - BitField<3, 1, s32> handheld_right; - BitField<4, 1, s32> joycon_left; - BitField<5, 1, s32> joycon_right; - BitField<6, 1, s32> palma; - BitField<7, 1, s32> lark_hvc_left; - BitField<8, 1, s32> lark_hvc_right; - BitField<9, 1, s32> lark_nes_left; - BitField<10, 1, s32> lark_nes_right; - BitField<11, 1, s32> handheld_lark_hvc_left; - BitField<12, 1, s32> handheld_lark_hvc_right; - BitField<13, 1, s32> handheld_lark_nes_left; - BitField<14, 1, s32> handheld_lark_nes_right; - BitField<15, 1, s32> lucia; - BitField<16, 1, s32> lagon; - BitField<17, 1, s32> lager; - BitField<31, 1, s32> system; - }; - }; - - // This is nn::hid::detail::NfcXcdDeviceHandleStateImpl - struct NfcXcdDeviceHandleStateImpl { - u64 handle{}; - bool is_available{}; - bool is_activated{}; - INSERT_PADDING_BYTES(0x6); // Reserved - u64 sampling_number{}; - }; - static_assert(sizeof(NfcXcdDeviceHandleStateImpl) == 0x18, - "NfcXcdDeviceHandleStateImpl is an invalid size"); - - // This is nn::hid::NpadLarkType - enum class NpadLarkType : u32 { - Invalid, - H1, - H2, - NL, - NR, - }; - - // This is nn::hid::NpadLuciaType - enum class NpadLuciaType : u32 { - Invalid, - J, - E, - U, - }; - - // This is nn::hid::NpadLagonType - enum class NpadLagonType : u32 { - Invalid, - }; - - // This is nn::hid::NpadLagerType - enum class NpadLagerType : u32 { - Invalid, - J, - E, - U, - }; - - // This is nn::hid::detail::NpadInternalState - struct NpadInternalState { - Core::HID::NpadStyleTag style_tag{Core::HID::NpadStyleSet::None}; - NpadJoyAssignmentMode assignment_mode{NpadJoyAssignmentMode::Dual}; - NpadFullKeyColorState fullkey_color{}; - NpadJoyColorState joycon_color{}; - Lifo<NPadGenericState, hid_entry_count> fullkey_lifo{}; - Lifo<NPadGenericState, hid_entry_count> handheld_lifo{}; - Lifo<NPadGenericState, hid_entry_count> joy_dual_lifo{}; - Lifo<NPadGenericState, hid_entry_count> joy_left_lifo{}; - Lifo<NPadGenericState, hid_entry_count> joy_right_lifo{}; - Lifo<NPadGenericState, hid_entry_count> palma_lifo{}; - Lifo<NPadGenericState, hid_entry_count> system_ext_lifo{}; - Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_fullkey_lifo{}; - Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_handheld_lifo{}; - Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_dual_left_lifo{}; - Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_dual_right_lifo{}; - Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_left_lifo{}; - Lifo<Core::HID::SixAxisSensorState, hid_entry_count> sixaxis_right_lifo{}; - DeviceType device_type{}; - INSERT_PADDING_BYTES(0x4); // Reserved - NPadSystemProperties system_properties{}; - NpadSystemButtonProperties button_properties{}; - Core::HID::NpadBatteryLevel battery_level_dual{}; - Core::HID::NpadBatteryLevel battery_level_left{}; - Core::HID::NpadBatteryLevel battery_level_right{}; - AppletFooterUiAttributes applet_footer_attributes{}; - AppletFooterUiType applet_footer_type{AppletFooterUiType::None}; - INSERT_PADDING_BYTES(0x5B); // Reserved - INSERT_PADDING_BYTES(0x20); // Unknown - Lifo<NpadGcTriggerState, hid_entry_count> gc_trigger_lifo{}; - NpadLarkType lark_type_l_and_main{}; - NpadLarkType lark_type_r{}; - NpadLuciaType lucia_type{}; - NpadLagonType lagon_type{}; - NpadLagerType lager_type{}; - Core::HID::SixAxisSensorProperties sixaxis_fullkey_properties; - Core::HID::SixAxisSensorProperties sixaxis_handheld_properties; - Core::HID::SixAxisSensorProperties sixaxis_dual_left_properties; - Core::HID::SixAxisSensorProperties sixaxis_dual_right_properties; - Core::HID::SixAxisSensorProperties sixaxis_left_properties; - Core::HID::SixAxisSensorProperties sixaxis_right_properties; - INSERT_PADDING_BYTES(0xc06); // Unknown - }; - static_assert(sizeof(NpadInternalState) == 0x5000, "NpadInternalState is an invalid size"); - struct VibrationData { bool device_mounted{}; Core::HID::VibrationValue latest_vibration_value{}; @@ -479,7 +189,7 @@ private: std::atomic<u64> press_state{}; - std::array<NpadControllerData, NPAD_COUNT> controller_data{}; + std::array<NpadControllerData, NpadCount> controller_data{}; KernelHelpers::ServiceContext& service_context; std::mutex mutex; std::vector<Core::HID::NpadIdType> supported_npad_id_types{}; diff --git a/src/core/hle/service/hid/controllers/palma.cpp b/src/core/hle/service/hid/controllers/palma.cpp index 588ff9d62..aa0454b5e 100644 --- a/src/core/hle/service/hid/controllers/palma.cpp +++ b/src/core/hle/service/hid/controllers/palma.cpp @@ -12,8 +12,7 @@ namespace Service::HID { -Palma::Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_, - KernelHelpers::ServiceContext& service_context_) +Palma::Palma(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service_context_) : ControllerBase{hid_core_}, service_context{service_context_} { controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Other); operation_complete_event = service_context.CreateEvent("hid:PalmaOperationCompleteEvent"); diff --git a/src/core/hle/service/hid/controllers/palma.h b/src/core/hle/service/hid/controllers/palma.h index a6047f36a..73884230d 100644 --- a/src/core/hle/service/hid/controllers/palma.h +++ b/src/core/hle/service/hid/controllers/palma.h @@ -97,8 +97,7 @@ public: static_assert(sizeof(PalmaConnectionHandle) == 0x8, "PalmaConnectionHandle has incorrect size."); - explicit Palma(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_, - KernelHelpers::ServiceContext& service_context_); + explicit Palma(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service_context_); ~Palma() override; // Called when the controller is initialized diff --git a/src/core/hle/service/hid/controllers/shared_memory_format.h b/src/core/hle/service/hid/controllers/shared_memory_format.h new file mode 100644 index 000000000..2986c113e --- /dev/null +++ b/src/core/hle/service/hid/controllers/shared_memory_format.h @@ -0,0 +1,240 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include "common/common_funcs.h" +#include "common/common_types.h" +#include "common/vector_math.h" +#include "core/hid/hid_types.h" +#include "core/hle/service/hid//controllers/types/debug_pad_types.h" +#include "core/hle/service/hid//controllers/types/keyboard_types.h" +#include "core/hle/service/hid//controllers/types/mouse_types.h" +#include "core/hle/service/hid//controllers/types/npad_types.h" +#include "core/hle/service/hid//controllers/types/touch_types.h" +#include "core/hle/service/hid/ring_lifo.h" + +namespace Service::HID { +static const std::size_t HidEntryCount = 17; + +struct CommonHeader { + s64 timestamp{}; + s64 total_entry_count{}; + s64 last_entry_index{}; + s64 entry_count{}; +}; +static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size"); + +// This is nn::hid::detail::DebugPadSharedMemoryFormat +struct DebugPadSharedMemoryFormat { + // This is nn::hid::detail::DebugPadLifo + Lifo<DebugPadState, HidEntryCount> debug_pad_lifo{}; + static_assert(sizeof(debug_pad_lifo) == 0x2C8, "debug_pad_lifo is an invalid size"); + INSERT_PADDING_WORDS(0x4E); +}; +static_assert(sizeof(DebugPadSharedMemoryFormat) == 0x400, + "DebugPadSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::TouchScreenSharedMemoryFormat +struct TouchScreenSharedMemoryFormat { + // This is nn::hid::detail::TouchScreenLifo + Lifo<TouchScreenState, HidEntryCount> touch_screen_lifo{}; + static_assert(sizeof(touch_screen_lifo) == 0x2C38, "touch_screen_lifo is an invalid size"); + INSERT_PADDING_WORDS(0xF2); +}; +static_assert(sizeof(TouchScreenSharedMemoryFormat) == 0x3000, + "TouchScreenSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::MouseSharedMemoryFormat +struct MouseSharedMemoryFormat { + // This is nn::hid::detail::MouseLifo + Lifo<Core::HID::MouseState, HidEntryCount> mouse_lifo{}; + static_assert(sizeof(mouse_lifo) == 0x350, "mouse_lifo is an invalid size"); + INSERT_PADDING_WORDS(0x2C); +}; +static_assert(sizeof(MouseSharedMemoryFormat) == 0x400, + "MouseSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::KeyboardSharedMemoryFormat +struct KeyboardSharedMemoryFormat { + // This is nn::hid::detail::KeyboardLifo + Lifo<KeyboardState, HidEntryCount> keyboard_lifo{}; + static_assert(sizeof(keyboard_lifo) == 0x3D8, "keyboard_lifo is an invalid size"); + INSERT_PADDING_WORDS(0xA); +}; +static_assert(sizeof(KeyboardSharedMemoryFormat) == 0x400, + "KeyboardSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::DigitizerSharedMemoryFormat +struct DigitizerSharedMemoryFormat { + CommonHeader header; + INSERT_PADDING_BYTES(0xFE0); +}; +static_assert(sizeof(DigitizerSharedMemoryFormat) == 0x1000, + "DigitizerSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::HomeButtonSharedMemoryFormat +struct HomeButtonSharedMemoryFormat { + CommonHeader header; + INSERT_PADDING_BYTES(0x1E0); +}; +static_assert(sizeof(HomeButtonSharedMemoryFormat) == 0x200, + "HomeButtonSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::SleepButtonSharedMemoryFormat +struct SleepButtonSharedMemoryFormat { + CommonHeader header; + INSERT_PADDING_BYTES(0x1E0); +}; +static_assert(sizeof(SleepButtonSharedMemoryFormat) == 0x200, + "SleepButtonSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::CaptureButtonSharedMemoryFormat +struct CaptureButtonSharedMemoryFormat { + CommonHeader header; + INSERT_PADDING_BYTES(0x1E0); +}; +static_assert(sizeof(CaptureButtonSharedMemoryFormat) == 0x200, + "CaptureButtonSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::InputDetectorSharedMemoryFormat +struct InputDetectorSharedMemoryFormat { + CommonHeader header; + INSERT_PADDING_BYTES(0x7E0); +}; +static_assert(sizeof(InputDetectorSharedMemoryFormat) == 0x800, + "InputDetectorSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::UniquePadSharedMemoryFormat +struct UniquePadSharedMemoryFormat { + CommonHeader header; + INSERT_PADDING_BYTES(0x3FE0); +}; +static_assert(sizeof(UniquePadSharedMemoryFormat) == 0x4000, + "UniquePadSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::NpadSixAxisSensorLifo +struct NpadSixAxisSensorLifo { + Lifo<Core::HID::SixAxisSensorState, HidEntryCount> lifo; +}; + +// This is nn::hid::detail::NpadInternalState +struct NpadInternalState { + Core::HID::NpadStyleTag style_tag{Core::HID::NpadStyleSet::None}; + NpadJoyAssignmentMode assignment_mode{NpadJoyAssignmentMode::Dual}; + NpadFullKeyColorState fullkey_color{}; + NpadJoyColorState joycon_color{}; + Lifo<NPadGenericState, HidEntryCount> fullkey_lifo{}; + Lifo<NPadGenericState, HidEntryCount> handheld_lifo{}; + Lifo<NPadGenericState, HidEntryCount> joy_dual_lifo{}; + Lifo<NPadGenericState, HidEntryCount> joy_left_lifo{}; + Lifo<NPadGenericState, HidEntryCount> joy_right_lifo{}; + Lifo<NPadGenericState, HidEntryCount> palma_lifo{}; + Lifo<NPadGenericState, HidEntryCount> system_ext_lifo{}; + NpadSixAxisSensorLifo sixaxis_fullkey_lifo{}; + NpadSixAxisSensorLifo sixaxis_handheld_lifo{}; + NpadSixAxisSensorLifo sixaxis_dual_left_lifo{}; + NpadSixAxisSensorLifo sixaxis_dual_right_lifo{}; + NpadSixAxisSensorLifo sixaxis_left_lifo{}; + NpadSixAxisSensorLifo sixaxis_right_lifo{}; + DeviceType device_type{}; + INSERT_PADDING_BYTES(0x4); // Reserved + NPadSystemProperties system_properties{}; + NpadSystemButtonProperties button_properties{}; + Core::HID::NpadBatteryLevel battery_level_dual{}; + Core::HID::NpadBatteryLevel battery_level_left{}; + Core::HID::NpadBatteryLevel battery_level_right{}; + AppletFooterUiAttributes applet_footer_attributes{}; + AppletFooterUiType applet_footer_type{AppletFooterUiType::None}; + INSERT_PADDING_BYTES(0x5B); // Reserved + INSERT_PADDING_BYTES(0x20); // Unknown + Lifo<NpadGcTriggerState, HidEntryCount> gc_trigger_lifo{}; + NpadLarkType lark_type_l_and_main{}; + NpadLarkType lark_type_r{}; + NpadLuciaType lucia_type{}; + NpadLagerType lager_type{}; + Core::HID::SixAxisSensorProperties sixaxis_fullkey_properties; + Core::HID::SixAxisSensorProperties sixaxis_handheld_properties; + Core::HID::SixAxisSensorProperties sixaxis_dual_left_properties; + Core::HID::SixAxisSensorProperties sixaxis_dual_right_properties; + Core::HID::SixAxisSensorProperties sixaxis_left_properties; + Core::HID::SixAxisSensorProperties sixaxis_right_properties; +}; +static_assert(sizeof(NpadInternalState) == 0x43F8, "NpadInternalState is an invalid size"); + +// This is nn::hid::detail::NpadSharedMemoryEntry +struct NpadSharedMemoryEntry { + NpadInternalState internal_state; + INSERT_PADDING_BYTES(0xC08); +}; +static_assert(sizeof(NpadSharedMemoryEntry) == 0x5000, "NpadSharedMemoryEntry is an invalid size"); + +// This is nn::hid::detail::NpadSharedMemoryFormat +struct NpadSharedMemoryFormat { + std::array<NpadSharedMemoryEntry, NpadCount> npad_entry; +}; +static_assert(sizeof(NpadSharedMemoryFormat) == 0x32000, + "NpadSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::GestureSharedMemoryFormat +struct GestureSharedMemoryFormat { + // This is nn::hid::detail::GestureLifo + Lifo<GestureState, HidEntryCount> gesture_lifo{}; + static_assert(sizeof(gesture_lifo) == 0x708, "gesture_lifo is an invalid size"); + INSERT_PADDING_WORDS(0x3E); +}; +static_assert(sizeof(GestureSharedMemoryFormat) == 0x800, + "GestureSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::ConsoleSixAxisSensorSharedMemoryFormat +struct ConsoleSixAxisSensorSharedMemoryFormat { + u64 sampling_number{}; + bool is_seven_six_axis_sensor_at_rest{}; + INSERT_PADDING_BYTES(3); // padding + f32 verticalization_error{}; + Common::Vec3f gyro_bias{}; + INSERT_PADDING_BYTES(4); // padding +}; +static_assert(sizeof(ConsoleSixAxisSensorSharedMemoryFormat) == 0x20, + "ConsoleSixAxisSensorSharedMemoryFormat is an invalid size"); + +// This is nn::hid::detail::SharedMemoryFormat +struct SharedMemoryFormat { + void Initialize() {} + + DebugPadSharedMemoryFormat debug_pad; + TouchScreenSharedMemoryFormat touch_screen; + MouseSharedMemoryFormat mouse; + KeyboardSharedMemoryFormat keyboard; + DigitizerSharedMemoryFormat digitizer; + HomeButtonSharedMemoryFormat home_button; + SleepButtonSharedMemoryFormat sleep_button; + CaptureButtonSharedMemoryFormat capture_button; + InputDetectorSharedMemoryFormat input_detector; + UniquePadSharedMemoryFormat unique_pad; + NpadSharedMemoryFormat npad; + GestureSharedMemoryFormat gesture; + ConsoleSixAxisSensorSharedMemoryFormat console; + INSERT_PADDING_BYTES(0x19E0); + MouseSharedMemoryFormat debug_mouse; + INSERT_PADDING_BYTES(0x2000); +}; +static_assert(offsetof(SharedMemoryFormat, debug_pad) == 0x0, "debug_pad has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, touch_screen) == 0x400, "touch_screen has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, mouse) == 0x3400, "mouse has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, keyboard) == 0x3800, "keyboard has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, digitizer) == 0x3C00, "digitizer has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, home_button) == 0x4C00, "home_button has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, sleep_button) == 0x4E00, + "sleep_button has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, capture_button) == 0x5000, + "capture_button has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, input_detector) == 0x5200, + "input_detector has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, npad) == 0x9A00, "npad has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, gesture) == 0x3BA00, "gesture has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, console) == 0x3C200, "console has wrong offset"); +static_assert(offsetof(SharedMemoryFormat, debug_mouse) == 0x3DC00, "debug_mouse has wrong offset"); +static_assert(sizeof(SharedMemoryFormat) == 0x40000, "SharedMemoryFormat is an invalid size"); + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/shared_memory_holder.cpp b/src/core/hle/service/hid/controllers/shared_memory_holder.cpp new file mode 100644 index 000000000..51581188e --- /dev/null +++ b/src/core/hle/service/hid/controllers/shared_memory_holder.cpp @@ -0,0 +1,53 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "core/core.h" +#include "core/hle/kernel/k_shared_memory.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" +#include "core/hle/service/hid/controllers/shared_memory_holder.h" +#include "core/hle/service/hid/errors.h" + +namespace Service::HID { +SharedMemoryHolder::SharedMemoryHolder() {} + +SharedMemoryHolder::~SharedMemoryHolder() { + Finalize(); +} + +Result SharedMemoryHolder::Initialize(Core::System& system) { + shared_memory = Kernel::KSharedMemory::Create(system.Kernel()); + const Result result = shared_memory->Initialize( + system.DeviceMemory(), nullptr, Kernel::Svc::MemoryPermission::None, + Kernel::Svc::MemoryPermission::Read, sizeof(SharedMemoryFormat)); + if (result.IsError()) { + return result; + } + Kernel::KSharedMemory::Register(system.Kernel(), shared_memory); + + is_created = true; + is_mapped = true; + address = std::construct_at(reinterpret_cast<SharedMemoryFormat*>(shared_memory->GetPointer())); + return ResultSuccess; +} + +void SharedMemoryHolder::Finalize() { + if (address != nullptr) { + shared_memory->Close(); + } + is_created = false; + is_mapped = false; + address = nullptr; +} + +bool SharedMemoryHolder::IsMapped() { + return is_mapped; +} + +SharedMemoryFormat* SharedMemoryHolder::GetAddress() { + return address; +} + +Kernel::KSharedMemory* SharedMemoryHolder::GetHandle() { + return shared_memory; +} +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/shared_memory_holder.h b/src/core/hle/service/hid/controllers/shared_memory_holder.h new file mode 100644 index 000000000..943407c00 --- /dev/null +++ b/src/core/hle/service/hid/controllers/shared_memory_holder.h @@ -0,0 +1,44 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include "core/hle/result.h" + +namespace Core { +class System; +} + +namespace Kernel { +class KSharedMemory; +} + +namespace Service::HID { +struct SharedMemoryFormat; + +// This is nn::hid::detail::SharedMemoryHolder +class SharedMemoryHolder { +public: + SharedMemoryHolder(); + ~SharedMemoryHolder(); + + Result Initialize(Core::System& system); + void Finalize(); + + bool IsMapped(); + SharedMemoryFormat* GetAddress(); + Kernel::KSharedMemory* GetHandle(); + +private: + bool is_owner{}; + bool is_created{}; + bool is_mapped{}; + INSERT_PADDING_BYTES(0x5); + Kernel::KSharedMemory* shared_memory; + INSERT_PADDING_BYTES(0x38); + SharedMemoryFormat* address = nullptr; +}; +// Correct size is 0x50 bytes +static_assert(sizeof(SharedMemoryHolder) == 0x50, "SharedMemoryHolder is an invalid size"); + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/six_axis.cpp b/src/core/hle/service/hid/controllers/six_axis.cpp index 3d24a5c04..36b72f9ea 100644 --- a/src/core/hle/service/hid/controllers/six_axis.cpp +++ b/src/core/hle/service/hid/controllers/six_axis.cpp @@ -6,6 +6,7 @@ #include "core/hid/emulated_controller.h" #include "core/hid/hid_core.h" #include "core/hle/service/hid/controllers/npad.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" #include "core/hle/service/hid/controllers/six_axis.h" #include "core/hle/service/hid/errors.h" #include "core/hle/service/hid/hid_util.h" @@ -132,30 +133,30 @@ void SixAxis::OnUpdate(const Core::Timing::CoreTiming& core_timing) { } sixaxis_fullkey_state.sampling_number = - sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1; + sixaxis_fullkey_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1; sixaxis_handheld_state.sampling_number = - sixaxis_handheld_lifo.ReadCurrentEntry().state.sampling_number + 1; + sixaxis_handheld_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1; sixaxis_dual_left_state.sampling_number = - sixaxis_dual_left_lifo.ReadCurrentEntry().state.sampling_number + 1; + sixaxis_dual_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1; sixaxis_dual_right_state.sampling_number = - sixaxis_dual_right_lifo.ReadCurrentEntry().state.sampling_number + 1; + sixaxis_dual_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1; sixaxis_left_lifo_state.sampling_number = - sixaxis_left_lifo.ReadCurrentEntry().state.sampling_number + 1; + sixaxis_left_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1; sixaxis_right_lifo_state.sampling_number = - sixaxis_right_lifo.ReadCurrentEntry().state.sampling_number + 1; + sixaxis_right_lifo.lifo.ReadCurrentEntry().state.sampling_number + 1; if (IndexToNpadIdType(i) == Core::HID::NpadIdType::Handheld) { // This buffer only is updated on handheld on HW - sixaxis_handheld_lifo.WriteNextEntry(sixaxis_handheld_state); + sixaxis_handheld_lifo.lifo.WriteNextEntry(sixaxis_handheld_state); } else { // Handheld doesn't update this buffer on HW - sixaxis_fullkey_lifo.WriteNextEntry(sixaxis_fullkey_state); + sixaxis_fullkey_lifo.lifo.WriteNextEntry(sixaxis_fullkey_state); } - sixaxis_dual_left_lifo.WriteNextEntry(sixaxis_dual_left_state); - sixaxis_dual_right_lifo.WriteNextEntry(sixaxis_dual_right_state); - sixaxis_left_lifo.WriteNextEntry(sixaxis_left_lifo_state); - sixaxis_right_lifo.WriteNextEntry(sixaxis_right_lifo_state); + sixaxis_dual_left_lifo.lifo.WriteNextEntry(sixaxis_dual_left_state); + sixaxis_dual_right_lifo.lifo.WriteNextEntry(sixaxis_dual_right_state); + sixaxis_left_lifo.lifo.WriteNextEntry(sixaxis_left_lifo_state); + sixaxis_right_lifo.lifo.WriteNextEntry(sixaxis_right_lifo_state); } } diff --git a/src/core/hle/service/hid/controllers/stubbed.cpp b/src/core/hle/service/hid/controllers/stubbed.cpp index 9e2f3ab21..e2a5f5d79 100644 --- a/src/core/hle/service/hid/controllers/stubbed.cpp +++ b/src/core/hle/service/hid/controllers/stubbed.cpp @@ -1,18 +1,15 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <cstring> -#include "common/common_types.h" #include "core/core_timing.h" -#include "core/hid/hid_core.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" #include "core/hle/service/hid/controllers/stubbed.h" namespace Service::HID { -Controller_Stubbed::Controller_Stubbed(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) - : ControllerBase{hid_core_} { - raw_shared_memory = raw_shared_memory_; -} +Controller_Stubbed::Controller_Stubbed(Core::HID::HIDCore& hid_core_, + CommonHeader& ring_lifo_header) + : ControllerBase{hid_core_}, header{ring_lifo_header} {} Controller_Stubbed::~Controller_Stubbed() = default; @@ -25,18 +22,10 @@ void Controller_Stubbed::OnUpdate(const Core::Timing::CoreTiming& core_timing) { return; } - CommonHeader header{}; header.timestamp = core_timing.GetGlobalTimeNs().count(); header.total_entry_count = 17; header.entry_count = 0; header.last_entry_index = 0; - - std::memcpy(raw_shared_memory + common_offset, &header, sizeof(CommonHeader)); -} - -void Controller_Stubbed::SetCommonHeaderOffset(std::size_t off) { - common_offset = off; - smart_update = true; } } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/stubbed.h b/src/core/hle/service/hid/controllers/stubbed.h index 1483a968e..d2052fb17 100644 --- a/src/core/hle/service/hid/controllers/stubbed.h +++ b/src/core/hle/service/hid/controllers/stubbed.h @@ -3,13 +3,14 @@ #pragma once -#include "common/common_types.h" #include "core/hle/service/hid/controllers/controller_base.h" namespace Service::HID { +struct CommonHeader; + class Controller_Stubbed final : public ControllerBase { public: - explicit Controller_Stubbed(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); + explicit Controller_Stubbed(Core::HID::HIDCore& hid_core_, CommonHeader& ring_lifo_header); ~Controller_Stubbed() override; // Called when the controller is initialized @@ -21,19 +22,8 @@ public: // When the controller is requesting an update for the shared memory void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; - void SetCommonHeaderOffset(std::size_t off); - private: - struct CommonHeader { - s64 timestamp{}; - s64 total_entry_count{}; - s64 last_entry_index{}; - s64 entry_count{}; - }; - static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size"); - - u8* raw_shared_memory = nullptr; + CommonHeader& header; bool smart_update{}; - std::size_t common_offset{}; }; } // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/touchscreen.cpp b/src/core/hle/service/hid/controllers/touchscreen.cpp index fcd973414..469750006 100644 --- a/src/core/hle/service/hid/controllers/touchscreen.cpp +++ b/src/core/hle/service/hid/controllers/touchscreen.cpp @@ -2,26 +2,22 @@ // SPDX-License-Identifier: GPL-2.0-or-later #include <algorithm> -#include <cstring> #include "common/common_types.h" #include "common/settings.h" -#include "core/core.h" #include "core/core_timing.h" #include "core/frontend/emu_window.h" #include "core/hid/emulated_console.h" #include "core/hid/hid_core.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" #include "core/hle/service/hid/controllers/touchscreen.h" namespace Service::HID { -constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400; -TouchScreen::TouchScreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) - : ControllerBase{hid_core_}, touchscreen_width(Layout::ScreenUndocked::Width), +TouchScreen::TouchScreen(Core::HID::HIDCore& hid_core_, + TouchScreenSharedMemoryFormat& touch_shared_memory) + : ControllerBase{hid_core_}, shared_memory{touch_shared_memory}, + touchscreen_width(Layout::ScreenUndocked::Width), touchscreen_height(Layout::ScreenUndocked::Height) { - static_assert(SHARED_MEMORY_OFFSET + sizeof(TouchSharedMemory) < shared_memory_size, - "TouchSharedMemory is bigger than the shared memory"); - shared_memory = std::construct_at( - reinterpret_cast<TouchSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); console = hid_core.GetEmulatedConsole(); } @@ -32,11 +28,11 @@ void TouchScreen::OnInit() {} void TouchScreen::OnRelease() {} void TouchScreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) { - shared_memory->touch_screen_lifo.timestamp = core_timing.GetGlobalTimeNs().count(); + shared_memory.touch_screen_lifo.timestamp = core_timing.GetGlobalTimeNs().count(); if (!IsControllerActivated()) { - shared_memory->touch_screen_lifo.buffer_count = 0; - shared_memory->touch_screen_lifo.buffer_tail = 0; + shared_memory.touch_screen_lifo.buffer_count = 0; + shared_memory.touch_screen_lifo.buffer_tail = 0; return; } @@ -86,7 +82,7 @@ void TouchScreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) { static_cast<std::size_t>(std::distance(active_fingers.begin(), end_iter)); const u64 timestamp = static_cast<u64>(core_timing.GetGlobalTimeNs().count()); - const auto& last_entry = shared_memory->touch_screen_lifo.ReadCurrentEntry().state; + const auto& last_entry = shared_memory.touch_screen_lifo.ReadCurrentEntry().state; next_state.sampling_number = last_entry.sampling_number + 1; next_state.entry_count = static_cast<s32>(active_fingers_count); @@ -118,7 +114,7 @@ void TouchScreen::OnUpdate(const Core::Timing::CoreTiming& core_timing) { } } - shared_memory->touch_screen_lifo.WriteNextEntry(next_state); + shared_memory.touch_screen_lifo.WriteNextEntry(next_state); } void TouchScreen::SetTouchscreenDimensions(u32 width, u32 height) { diff --git a/src/core/hle/service/hid/controllers/touchscreen.h b/src/core/hle/service/hid/controllers/touchscreen.h index 79f026a81..5b6305bfc 100644 --- a/src/core/hle/service/hid/controllers/touchscreen.h +++ b/src/core/hle/service/hid/controllers/touchscreen.h @@ -3,20 +3,23 @@ #pragma once -#include "common/common_funcs.h" -#include "common/common_types.h" +#include <array> + #include "core/hid/hid_types.h" #include "core/hle/service/hid/controllers/controller_base.h" -#include "core/hle/service/hid/ring_lifo.h" +#include "core/hle/service/hid/controllers/types/touch_types.h" namespace Core::HID { class EmulatedConsole; } // namespace Core::HID namespace Service::HID { +struct TouchScreenSharedMemoryFormat; + class TouchScreen final : public ControllerBase { public: - explicit TouchScreen(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); + explicit TouchScreen(Core::HID::HIDCore& hid_core_, + TouchScreenSharedMemoryFormat& touch_shared_memory); ~TouchScreen() override; // Called when the controller is initialized @@ -31,27 +34,8 @@ public: void SetTouchscreenDimensions(u32 width, u32 height); private: - static constexpr std::size_t MAX_FINGERS = 16; - - // This is nn::hid::TouchScreenState - struct TouchScreenState { - s64 sampling_number{}; - s32 entry_count{}; - INSERT_PADDING_BYTES(4); // Reserved - std::array<Core::HID::TouchState, MAX_FINGERS> states{}; - }; - static_assert(sizeof(TouchScreenState) == 0x290, "TouchScreenState is an invalid size"); - - struct TouchSharedMemory { - // This is nn::hid::detail::TouchScreenLifo - Lifo<TouchScreenState, hid_entry_count> touch_screen_lifo{}; - static_assert(sizeof(touch_screen_lifo) == 0x2C38, "touch_screen_lifo is an invalid size"); - INSERT_PADDING_WORDS(0xF2); - }; - static_assert(sizeof(TouchSharedMemory) == 0x3000, "TouchSharedMemory is an invalid size"); - TouchScreenState next_state{}; - TouchSharedMemory* shared_memory = nullptr; + TouchScreenSharedMemoryFormat& shared_memory; Core::HID::EmulatedConsole* console = nullptr; std::array<Core::HID::TouchFinger, MAX_FINGERS> fingers{}; diff --git a/src/core/hle/service/hid/controllers/types/debug_pad_types.h b/src/core/hle/service/hid/controllers/types/debug_pad_types.h new file mode 100644 index 000000000..a96171b62 --- /dev/null +++ b/src/core/hle/service/hid/controllers/types/debug_pad_types.h @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include "common/bit_field.h" +#include "common/common_types.h" +#include "core/hid/hid_types.h" + +namespace Service::HID { + +// This is nn::hid::DebugPadAttribute +struct DebugPadAttribute { + union { + u32 raw{}; + BitField<0, 1, u32> connected; + }; +}; +static_assert(sizeof(DebugPadAttribute) == 0x4, "DebugPadAttribute is an invalid size"); + +// This is nn::hid::DebugPadState +struct DebugPadState { + s64 sampling_number{}; + DebugPadAttribute attribute{}; + Core::HID::DebugPadButton pad_state{}; + Core::HID::AnalogStickState r_stick{}; + Core::HID::AnalogStickState l_stick{}; +}; +static_assert(sizeof(DebugPadState) == 0x20, "DebugPadState is an invalid state"); + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/types/gesture_types.h b/src/core/hle/service/hid/controllers/types/gesture_types.h new file mode 100644 index 000000000..b4f034cd3 --- /dev/null +++ b/src/core/hle/service/hid/controllers/types/gesture_types.h @@ -0,0 +1,77 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include <array> +#include "common/bit_field.h" +#include "common/common_types.h" +#include "common/point.h" + +namespace Service::HID { +static constexpr size_t MAX_FINGERS = 16; +static constexpr size_t MAX_POINTS = 4; + +// This is nn::hid::GestureType +enum class GestureType : u32 { + Idle, // Nothing touching the screen + Complete, // Set at the end of a touch event + Cancel, // Set when the number of fingers change + Touch, // A finger just touched the screen + Press, // Set if last type is touch and the finger hasn't moved + Tap, // Fast press then release + Pan, // All points moving together across the screen + Swipe, // Fast press movement and release of a single point + Pinch, // All points moving away/closer to the midpoint + Rotate, // All points rotating from the midpoint +}; + +// This is nn::hid::GestureDirection +enum class GestureDirection : u32 { + None, + Left, + Up, + Right, + Down, +}; + +// This is nn::hid::GestureAttribute +struct GestureAttribute { + union { + u32 raw{}; + + BitField<4, 1, u32> is_new_touch; + BitField<8, 1, u32> is_double_tap; + }; +}; +static_assert(sizeof(GestureAttribute) == 4, "GestureAttribute is an invalid size"); + +// This is nn::hid::GestureState +struct GestureState { + s64 sampling_number{}; + s64 detection_count{}; + GestureType type{GestureType::Idle}; + GestureDirection direction{GestureDirection::None}; + Common::Point<s32> pos{}; + Common::Point<s32> delta{}; + f32 vel_x{}; + f32 vel_y{}; + GestureAttribute attributes{}; + f32 scale{}; + f32 rotation_angle{}; + s32 point_count{}; + std::array<Common::Point<s32>, 4> points{}; +}; +static_assert(sizeof(GestureState) == 0x60, "GestureState is an invalid size"); + +struct GestureProperties { + std::array<Common::Point<s32>, MAX_POINTS> points{}; + std::size_t active_points{}; + Common::Point<s32> mid_point{}; + s64 detection_count{}; + u64 delta_time{}; + f32 average_distance{}; + f32 angle{}; +}; + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/types/keyboard_types.h b/src/core/hle/service/hid/controllers/types/keyboard_types.h new file mode 100644 index 000000000..f44a536b9 --- /dev/null +++ b/src/core/hle/service/hid/controllers/types/keyboard_types.h @@ -0,0 +1,20 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include "common/common_types.h" +#include "core/hid/hid_types.h" + +namespace Service::HID { + +// This is nn::hid::detail::KeyboardState +struct KeyboardState { + s64 sampling_number{}; + Core::HID::KeyboardModifier modifier{}; + Core::HID::KeyboardAttribute attribute{}; + Core::HID::KeyboardKey key{}; +}; +static_assert(sizeof(KeyboardState) == 0x30, "KeyboardState is an invalid size"); + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/types/mouse_types.h b/src/core/hle/service/hid/controllers/types/mouse_types.h new file mode 100644 index 000000000..8bd6e167c --- /dev/null +++ b/src/core/hle/service/hid/controllers/types/mouse_types.h @@ -0,0 +1,8 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include "common/common_types.h" + +namespace Service::HID {} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/types/npad_types.h b/src/core/hle/service/hid/controllers/types/npad_types.h new file mode 100644 index 000000000..a5ce2562b --- /dev/null +++ b/src/core/hle/service/hid/controllers/types/npad_types.h @@ -0,0 +1,254 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include "common/bit_field.h" +#include "common/common_funcs.h" +#include "common/common_types.h" +#include "core/hid/hid_types.h" + +namespace Service::HID { +static constexpr std::size_t NpadCount = 10; + +// This is nn::hid::NpadJoyHoldType +enum class NpadJoyHoldType : u64 { + Vertical = 0, + Horizontal = 1, +}; + +// This is nn::hid::NpadJoyAssignmentMode +enum class NpadJoyAssignmentMode : u32 { + Dual = 0, + Single = 1, +}; + +// This is nn::hid::NpadJoyDeviceType +enum class NpadJoyDeviceType : s64 { + Left = 0, + Right = 1, +}; + +// This is nn::hid::NpadHandheldActivationMode +enum class NpadHandheldActivationMode : u64 { + Dual = 0, + Single = 1, + None = 2, + MaxActivationMode = 3, +}; + +// This is nn::hid::system::AppletFooterUiAttributesSet +struct AppletFooterUiAttributes { + INSERT_PADDING_BYTES(0x4); +}; + +// This is nn::hid::system::AppletFooterUiType +enum class AppletFooterUiType : u8 { + None = 0, + HandheldNone = 1, + HandheldJoyConLeftOnly = 2, + HandheldJoyConRightOnly = 3, + HandheldJoyConLeftJoyConRight = 4, + JoyDual = 5, + JoyDualLeftOnly = 6, + JoyDualRightOnly = 7, + JoyLeftHorizontal = 8, + JoyLeftVertical = 9, + JoyRightHorizontal = 10, + JoyRightVertical = 11, + SwitchProController = 12, + CompatibleProController = 13, + CompatibleJoyCon = 14, + LarkHvc1 = 15, + LarkHvc2 = 16, + LarkNesLeft = 17, + LarkNesRight = 18, + Lucia = 19, + Verification = 20, + Lagon = 21, +}; + +using AppletFooterUiVariant = u8; + +// This is "nn::hid::system::AppletDetailedUiType". +struct AppletDetailedUiType { + AppletFooterUiVariant ui_variant; + INSERT_PADDING_BYTES(0x2); + AppletFooterUiType footer; +}; +static_assert(sizeof(AppletDetailedUiType) == 0x4, "AppletDetailedUiType is an invalid size"); +// This is nn::hid::NpadCommunicationMode +enum class NpadCommunicationMode : u64 { + Mode_5ms = 0, + Mode_10ms = 1, + Mode_15ms = 2, + Default = 3, +}; + +enum class NpadRevision : u32 { + Revision0 = 0, + Revision1 = 1, + Revision2 = 2, + Revision3 = 3, +}; + +// This is nn::hid::detail::ColorAttribute +enum class ColorAttribute : u32 { + Ok = 0, + ReadError = 1, + NoController = 2, +}; +static_assert(sizeof(ColorAttribute) == 4, "ColorAttribute is an invalid size"); + +// This is nn::hid::detail::NpadFullKeyColorState +struct NpadFullKeyColorState { + ColorAttribute attribute{ColorAttribute::NoController}; + Core::HID::NpadControllerColor fullkey{}; +}; +static_assert(sizeof(NpadFullKeyColorState) == 0xC, "NpadFullKeyColorState is an invalid size"); + +// This is nn::hid::detail::NpadJoyColorState +struct NpadJoyColorState { + ColorAttribute attribute{ColorAttribute::NoController}; + Core::HID::NpadControllerColor left{}; + Core::HID::NpadControllerColor right{}; +}; +static_assert(sizeof(NpadJoyColorState) == 0x14, "NpadJoyColorState is an invalid size"); + +// This is nn::hid::NpadAttribute +struct NpadAttribute { + union { + u32 raw{}; + BitField<0, 1, u32> is_connected; + BitField<1, 1, u32> is_wired; + BitField<2, 1, u32> is_left_connected; + BitField<3, 1, u32> is_left_wired; + BitField<4, 1, u32> is_right_connected; + BitField<5, 1, u32> is_right_wired; + }; +}; +static_assert(sizeof(NpadAttribute) == 4, "NpadAttribute is an invalid size"); + +// This is nn::hid::NpadFullKeyState +// This is nn::hid::NpadHandheldState +// This is nn::hid::NpadJoyDualState +// This is nn::hid::NpadJoyLeftState +// This is nn::hid::NpadJoyRightState +// This is nn::hid::NpadPalmaState +// This is nn::hid::NpadSystemExtState +struct NPadGenericState { + s64_le sampling_number{}; + Core::HID::NpadButtonState npad_buttons{}; + Core::HID::AnalogStickState l_stick{}; + Core::HID::AnalogStickState r_stick{}; + NpadAttribute connection_status{}; + INSERT_PADDING_BYTES(4); // Reserved +}; +static_assert(sizeof(NPadGenericState) == 0x28, "NPadGenericState is an invalid size"); + +// This is nn::hid::server::NpadGcTriggerState +struct NpadGcTriggerState { + s64 sampling_number{}; + s32 l_analog{}; + s32 r_analog{}; +}; +static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size"); + +// This is nn::hid::NpadSystemProperties +struct NPadSystemProperties { + union { + s64 raw{}; + BitField<0, 1, s64> is_charging_joy_dual; + BitField<1, 1, s64> is_charging_joy_left; + BitField<2, 1, s64> is_charging_joy_right; + BitField<3, 1, s64> is_powered_joy_dual; + BitField<4, 1, s64> is_powered_joy_left; + BitField<5, 1, s64> is_powered_joy_right; + BitField<9, 1, s64> is_system_unsupported_button; + BitField<10, 1, s64> is_system_ext_unsupported_button; + BitField<11, 1, s64> is_vertical; + BitField<12, 1, s64> is_horizontal; + BitField<13, 1, s64> use_plus; + BitField<14, 1, s64> use_minus; + BitField<15, 1, s64> use_directional_buttons; + }; +}; +static_assert(sizeof(NPadSystemProperties) == 0x8, "NPadSystemProperties is an invalid size"); + +// This is nn::hid::NpadSystemButtonProperties +struct NpadSystemButtonProperties { + union { + s32 raw{}; + BitField<0, 1, s32> is_home_button_protection_enabled; + }; +}; +static_assert(sizeof(NpadSystemButtonProperties) == 0x4, "NPadButtonProperties is an invalid size"); + +// This is nn::hid::system::DeviceType +struct DeviceType { + union { + u32 raw{}; + BitField<0, 1, s32> fullkey; + BitField<1, 1, s32> debug_pad; + BitField<2, 1, s32> handheld_left; + BitField<3, 1, s32> handheld_right; + BitField<4, 1, s32> joycon_left; + BitField<5, 1, s32> joycon_right; + BitField<6, 1, s32> palma; + BitField<7, 1, s32> lark_hvc_left; + BitField<8, 1, s32> lark_hvc_right; + BitField<9, 1, s32> lark_nes_left; + BitField<10, 1, s32> lark_nes_right; + BitField<11, 1, s32> handheld_lark_hvc_left; + BitField<12, 1, s32> handheld_lark_hvc_right; + BitField<13, 1, s32> handheld_lark_nes_left; + BitField<14, 1, s32> handheld_lark_nes_right; + BitField<15, 1, s32> lucia; + BitField<16, 1, s32> lagon; + BitField<17, 1, s32> lager; + BitField<31, 1, s32> system; + }; +}; + +// This is nn::hid::detail::NfcXcdDeviceHandleStateImpl +struct NfcXcdDeviceHandleStateImpl { + u64 handle{}; + bool is_available{}; + bool is_activated{}; + INSERT_PADDING_BYTES(0x6); // Reserved + u64 sampling_number{}; +}; +static_assert(sizeof(NfcXcdDeviceHandleStateImpl) == 0x18, + "NfcXcdDeviceHandleStateImpl is an invalid size"); + +// This is nn::hid::NpadLarkType +enum class NpadLarkType : u32 { + Invalid, + H1, + H2, + NL, + NR, +}; + +// This is nn::hid::NpadLuciaType +enum class NpadLuciaType : u32 { + Invalid, + J, + E, + U, +}; + +// This is nn::hid::NpadLagonType +enum class NpadLagonType : u32 { + Invalid, +}; + +// This is nn::hid::NpadLagerType +enum class NpadLagerType : u32 { + Invalid, + J, + E, + U, +}; + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/types/touch_types.h b/src/core/hle/service/hid/controllers/types/touch_types.h new file mode 100644 index 000000000..efeaa796d --- /dev/null +++ b/src/core/hle/service/hid/controllers/types/touch_types.h @@ -0,0 +1,90 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include <array> + +#include <array> +#include "common/bit_field.h" +#include "common/common_funcs.h" +#include "common/common_types.h" +#include "common/point.h" +#include "core/hid/hid_types.h" + +namespace Service::HID { +static constexpr std::size_t MAX_FINGERS = 16; +static constexpr size_t MAX_POINTS = 4; + +// This is nn::hid::GestureType +enum class GestureType : u32 { + Idle, // Nothing touching the screen + Complete, // Set at the end of a touch event + Cancel, // Set when the number of fingers change + Touch, // A finger just touched the screen + Press, // Set if last type is touch and the finger hasn't moved + Tap, // Fast press then release + Pan, // All points moving together across the screen + Swipe, // Fast press movement and release of a single point + Pinch, // All points moving away/closer to the midpoint + Rotate, // All points rotating from the midpoint +}; + +// This is nn::hid::GestureDirection +enum class GestureDirection : u32 { + None, + Left, + Up, + Right, + Down, +}; + +// This is nn::hid::GestureAttribute +struct GestureAttribute { + union { + u32 raw{}; + + BitField<4, 1, u32> is_new_touch; + BitField<8, 1, u32> is_double_tap; + }; +}; +static_assert(sizeof(GestureAttribute) == 4, "GestureAttribute is an invalid size"); + +// This is nn::hid::GestureState +struct GestureState { + s64 sampling_number{}; + s64 detection_count{}; + GestureType type{GestureType::Idle}; + GestureDirection direction{GestureDirection::None}; + Common::Point<s32> pos{}; + Common::Point<s32> delta{}; + f32 vel_x{}; + f32 vel_y{}; + GestureAttribute attributes{}; + f32 scale{}; + f32 rotation_angle{}; + s32 point_count{}; + std::array<Common::Point<s32>, 4> points{}; +}; +static_assert(sizeof(GestureState) == 0x60, "GestureState is an invalid size"); + +struct GestureProperties { + std::array<Common::Point<s32>, MAX_POINTS> points{}; + std::size_t active_points{}; + Common::Point<s32> mid_point{}; + s64 detection_count{}; + u64 delta_time{}; + f32 average_distance{}; + f32 angle{}; +}; + +// This is nn::hid::TouchScreenState +struct TouchScreenState { + s64 sampling_number{}; + s32 entry_count{}; + INSERT_PADDING_BYTES(4); // Reserved + std::array<Core::HID::TouchState, MAX_FINGERS> states{}; +}; +static_assert(sizeof(TouchScreenState) == 0x290, "TouchScreenState is an invalid size"); + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/xpad.cpp b/src/core/hle/service/hid/controllers/xpad.cpp deleted file mode 100644 index 0aaed1fa7..000000000 --- a/src/core/hle/service/hid/controllers/xpad.cpp +++ /dev/null @@ -1,39 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#include <cstring> -#include "common/common_types.h" -#include "core/core_timing.h" -#include "core/hid/hid_core.h" -#include "core/hle/service/hid/controllers/xpad.h" - -namespace Service::HID { -constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00; - -XPad::XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_) : ControllerBase{hid_core_} { - static_assert(SHARED_MEMORY_OFFSET + sizeof(XpadSharedMemory) < shared_memory_size, - "XpadSharedMemory is bigger than the shared memory"); - shared_memory = std::construct_at( - reinterpret_cast<XpadSharedMemory*>(raw_shared_memory_ + SHARED_MEMORY_OFFSET)); -} -XPad::~XPad() = default; - -void XPad::OnInit() {} - -void XPad::OnRelease() {} - -void XPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) { - if (!IsControllerActivated()) { - shared_memory->basic_xpad_lifo.buffer_count = 0; - shared_memory->basic_xpad_lifo.buffer_tail = 0; - return; - } - - const auto& last_entry = shared_memory->basic_xpad_lifo.ReadCurrentEntry().state; - next_state.sampling_number = last_entry.sampling_number + 1; - // TODO(ogniK): Update xpad states - - shared_memory->basic_xpad_lifo.WriteNextEntry(next_state); -} - -} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/xpad.h b/src/core/hle/service/hid/controllers/xpad.h deleted file mode 100644 index 9e63a317a..000000000 --- a/src/core/hle/service/hid/controllers/xpad.h +++ /dev/null @@ -1,112 +0,0 @@ -// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project -// SPDX-License-Identifier: GPL-2.0-or-later - -#pragma once - -#include "common/bit_field.h" -#include "common/common_types.h" -#include "core/hid/hid_types.h" -#include "core/hle/service/hid/controllers/controller_base.h" -#include "core/hle/service/hid/ring_lifo.h" - -namespace Service::HID { -class XPad final : public ControllerBase { -public: - explicit XPad(Core::HID::HIDCore& hid_core_, u8* raw_shared_memory_); - ~XPad() override; - - // Called when the controller is initialized - void OnInit() override; - - // When the controller is released - void OnRelease() override; - - // When the controller is requesting an update for the shared memory - void OnUpdate(const Core::Timing::CoreTiming& core_timing) override; - -private: - // This is nn::hid::BasicXpadAttributeSet - struct BasicXpadAttributeSet { - union { - u32 raw{}; - BitField<0, 1, u32> is_connected; - BitField<1, 1, u32> is_wired; - BitField<2, 1, u32> is_left_connected; - BitField<3, 1, u32> is_left_wired; - BitField<4, 1, u32> is_right_connected; - BitField<5, 1, u32> is_right_wired; - }; - }; - static_assert(sizeof(BasicXpadAttributeSet) == 4, "BasicXpadAttributeSet is an invalid size"); - - // This is nn::hid::BasicXpadButtonSet - struct BasicXpadButtonSet { - union { - u32 raw{}; - // Button states - BitField<0, 1, u32> a; - BitField<1, 1, u32> b; - BitField<2, 1, u32> x; - BitField<3, 1, u32> y; - BitField<4, 1, u32> l_stick; - BitField<5, 1, u32> r_stick; - BitField<6, 1, u32> l; - BitField<7, 1, u32> r; - BitField<8, 1, u32> zl; - BitField<9, 1, u32> zr; - BitField<10, 1, u32> plus; - BitField<11, 1, u32> minus; - - // D-Pad - BitField<12, 1, u32> d_left; - BitField<13, 1, u32> d_up; - BitField<14, 1, u32> d_right; - BitField<15, 1, u32> d_down; - - // Left JoyStick - BitField<16, 1, u32> l_stick_left; - BitField<17, 1, u32> l_stick_up; - BitField<18, 1, u32> l_stick_right; - BitField<19, 1, u32> l_stick_down; - - // Right JoyStick - BitField<20, 1, u32> r_stick_left; - BitField<21, 1, u32> r_stick_up; - BitField<22, 1, u32> r_stick_right; - BitField<23, 1, u32> r_stick_down; - - // Not always active? - BitField<24, 1, u32> left_sl; - BitField<25, 1, u32> left_sr; - - BitField<26, 1, u32> right_sl; - BitField<27, 1, u32> right_sr; - - BitField<28, 1, u32> palma; - BitField<30, 1, u32> handheld_left_b; - }; - }; - static_assert(sizeof(BasicXpadButtonSet) == 4, "BasicXpadButtonSet is an invalid size"); - - // This is nn::hid::detail::BasicXpadState - struct BasicXpadState { - s64 sampling_number{}; - BasicXpadAttributeSet attributes{}; - BasicXpadButtonSet pad_states{}; - Core::HID::AnalogStickState l_stick{}; - Core::HID::AnalogStickState r_stick{}; - }; - static_assert(sizeof(BasicXpadState) == 0x20, "BasicXpadState is an invalid size"); - - struct XpadSharedMemory { - // This is nn::hid::detail::BasicXpadLifo - Lifo<BasicXpadState, hid_entry_count> basic_xpad_lifo{}; - static_assert(sizeof(basic_xpad_lifo) == 0x2C8, "basic_xpad_lifo is an invalid size"); - INSERT_PADDING_WORDS(0x4E); - }; - static_assert(sizeof(XpadSharedMemory) == 0x400, "XpadSharedMemory is an invalid size"); - - BasicXpadState next_state{}; - XpadSharedMemory* shared_memory = nullptr; -}; -} // namespace Service::HID diff --git a/src/core/hle/service/hid/errors.h b/src/core/hle/service/hid/errors.h index 9585bdaf0..6dc976fe1 100644 --- a/src/core/hle/service/hid/errors.h +++ b/src/core/hle/service/hid/errors.h @@ -19,6 +19,14 @@ constexpr Result NpadIsSameType{ErrorModule::HID, 602}; constexpr Result InvalidNpadId{ErrorModule::HID, 709}; constexpr Result NpadNotConnected{ErrorModule::HID, 710}; constexpr Result InvalidArraySize{ErrorModule::HID, 715}; + +constexpr Result ResultAppletResourceOverflow{ErrorModule::HID, 1041}; +constexpr Result ResultAppletResourceNotInitialized{ErrorModule::HID, 1042}; +constexpr Result ResultSharedMemoryNotInitialized{ErrorModule::HID, 1043}; +constexpr Result ResultAruidNoAvailableEntries{ErrorModule::HID, 1044}; +constexpr Result ResultAruidAlreadyRegistered{ErrorModule::HID, 1046}; +constexpr Result ResultAruidNotRegistered{ErrorModule::HID, 1047}; + constexpr Result InvalidPalmaHandle{ErrorModule::HID, 3302}; } // namespace Service::HID diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index 1b7381d8d..afbcb019f 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -1,6 +1,8 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/kernel.h" #include "core/hle/service/hid/hid.h" #include "core/hle/service/hid/hid_debug_server.h" #include "core/hle/service/hid/hid_firmware_settings.h" @@ -20,6 +22,12 @@ void LoopProcess(Core::System& system) { std::shared_ptr<HidFirmwareSettings> firmware_settings = std::make_shared<HidFirmwareSettings>(); + // TODO: Remove this hack until this service is emulated properly. + const auto process_list = system.Kernel().GetProcessList(); + if (!process_list.empty()) { + resouce_manager->RegisterAppletResourceUserId(process_list[0]->GetId(), true); + } + server_manager->RegisterNamedService( "hid", std::make_shared<IHidServer>(system, resouce_manager, firmware_settings)); server_manager->RegisterNamedService( diff --git a/src/core/hle/service/hid/hid_server.cpp b/src/core/hle/service/hid/hid_server.cpp index a7d1578d9..de24b0401 100644 --- a/src/core/hle/service/hid/hid_server.cpp +++ b/src/core/hle/service/hid/hid_server.cpp @@ -28,6 +28,7 @@ #include "core/hle/service/hid/controllers/seven_six_axis.h" #include "core/hle/service/hid/controllers/six_axis.h" #include "core/hle/service/hid/controllers/touchscreen.h" +#include "core/hle/service/hid/controllers/types/npad_types.h" namespace Service::HID { @@ -222,11 +223,14 @@ void IHidServer::CreateAppletResource(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; const auto applet_resource_user_id{rp.Pop<u64>()}; - LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id); + Result result = GetResourceManager()->CreateAppletResource(applet_resource_user_id); + + LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, result=0x{:X}", + applet_resource_user_id, result.raw); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; - rb.Push(ResultSuccess); - rb.PushIpcInterface<IAppletResource>(system, resource_manager); + rb.Push(result); + rb.PushIpcInterface<IAppletResource>(system, resource_manager, applet_resource_user_id); } void IHidServer::ActivateDebugPad(HLERequestContext& ctx) { @@ -1096,7 +1100,7 @@ void IHidServer::GetPlayerLedPattern(HLERequestContext& ctx) { void IHidServer::ActivateNpadWithRevision(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; struct Parameters { - NPad::NpadRevision revision; + NpadRevision revision; INSERT_PADDING_WORDS_NOINIT(1); u64 applet_resource_user_id; }; @@ -1119,7 +1123,7 @@ void IHidServer::ActivateNpadWithRevision(HLERequestContext& ctx) { void IHidServer::SetNpadJoyHoldType(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; const auto applet_resource_user_id{rp.Pop<u64>()}; - const auto hold_type{rp.PopEnum<NPad::NpadJoyHoldType>()}; + const auto hold_type{rp.PopEnum<NpadJoyHoldType>()}; GetResourceManager()->GetNpad()->SetHoldType(hold_type); @@ -1154,8 +1158,8 @@ void IHidServer::SetNpadJoyAssignmentModeSingleByDefault(HLERequestContext& ctx) Core::HID::NpadIdType new_npad_id{}; auto controller = GetResourceManager()->GetNpad(); - controller->SetNpadMode(new_npad_id, parameters.npad_id, NPad::NpadJoyDeviceType::Left, - NPad::NpadJoyAssignmentMode::Single); + controller->SetNpadMode(new_npad_id, parameters.npad_id, NpadJoyDeviceType::Left, + NpadJoyAssignmentMode::Single); LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", parameters.npad_id, parameters.applet_resource_user_id); @@ -1170,7 +1174,7 @@ void IHidServer::SetNpadJoyAssignmentModeSingle(HLERequestContext& ctx) { Core::HID::NpadIdType npad_id; INSERT_PADDING_WORDS_NOINIT(1); u64 applet_resource_user_id; - NPad::NpadJoyDeviceType npad_joy_device_type; + NpadJoyDeviceType npad_joy_device_type; }; static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size."); @@ -1179,7 +1183,7 @@ void IHidServer::SetNpadJoyAssignmentModeSingle(HLERequestContext& ctx) { Core::HID::NpadIdType new_npad_id{}; auto controller = GetResourceManager()->GetNpad(); controller->SetNpadMode(new_npad_id, parameters.npad_id, parameters.npad_joy_device_type, - NPad::NpadJoyAssignmentMode::Single); + NpadJoyAssignmentMode::Single); LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}", parameters.npad_id, parameters.applet_resource_user_id, @@ -1202,7 +1206,7 @@ void IHidServer::SetNpadJoyAssignmentModeDual(HLERequestContext& ctx) { Core::HID::NpadIdType new_npad_id{}; auto controller = GetResourceManager()->GetNpad(); - controller->SetNpadMode(new_npad_id, parameters.npad_id, {}, NPad::NpadJoyAssignmentMode::Dual); + controller->SetNpadMode(new_npad_id, parameters.npad_id, {}, NpadJoyAssignmentMode::Dual); LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", parameters.npad_id, parameters.applet_resource_user_id); // Spams a lot when controller applet is open @@ -1254,7 +1258,7 @@ void IHidServer::StopLrAssignmentMode(HLERequestContext& ctx) { void IHidServer::SetNpadHandheldActivationMode(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; const auto applet_resource_user_id{rp.Pop<u64>()}; - const auto activation_mode{rp.PopEnum<NPad::NpadHandheldActivationMode>()}; + const auto activation_mode{rp.PopEnum<NpadHandheldActivationMode>()}; GetResourceManager()->GetNpad()->SetNpadHandheldActivationMode(activation_mode); @@ -1346,7 +1350,7 @@ void IHidServer::SetNpadJoyAssignmentModeSingleWithDestination(HLERequestContext Core::HID::NpadIdType npad_id; INSERT_PADDING_WORDS_NOINIT(1); u64 applet_resource_user_id; - NPad::NpadJoyDeviceType npad_joy_device_type; + NpadJoyDeviceType npad_joy_device_type; }; static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size."); @@ -1356,7 +1360,7 @@ void IHidServer::SetNpadJoyAssignmentModeSingleWithDestination(HLERequestContext auto controller = GetResourceManager()->GetNpad(); const auto is_reassigned = controller->SetNpadMode(new_npad_id, parameters.npad_id, parameters.npad_joy_device_type, - NPad::NpadJoyAssignmentMode::Single); + NpadJoyAssignmentMode::Single); LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}", parameters.npad_id, parameters.applet_resource_user_id, @@ -2312,7 +2316,7 @@ void IHidServer::SetDisallowedPalmaConnection(HLERequestContext& ctx) { void IHidServer::SetNpadCommunicationMode(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; const auto applet_resource_user_id{rp.Pop<u64>()}; - const auto communication_mode{rp.PopEnum<NPad::NpadCommunicationMode>()}; + const auto communication_mode{rp.PopEnum<NpadCommunicationMode>()}; GetResourceManager()->GetNpad()->SetNpadCommunicationMode(communication_mode); diff --git a/src/core/hle/service/hid/hid_system_server.cpp b/src/core/hle/service/hid/hid_system_server.cpp index b56d0347a..5cc88c4a1 100644 --- a/src/core/hle/service/hid/hid_system_server.cpp +++ b/src/core/hle/service/hid/hid_system_server.cpp @@ -3,7 +3,9 @@ #include "core/hid/hid_core.h" #include "core/hle/service/hid/controllers/npad.h" +#include "core/hle/service/hid/controllers/palma.h" #include "core/hle/service/hid/controllers/touchscreen.h" +#include "core/hle/service/hid/controllers/types/npad_types.h" #include "core/hle/service/hid/errors.h" #include "core/hle/service/hid/hid_system_server.h" #include "core/hle/service/hid/resource_manager.h" @@ -63,13 +65,13 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour {329, nullptr, "DetachAbstractedPadAll"}, {330, nullptr, "CheckAbstractedPadConnection"}, {500, nullptr, "SetAppletResourceUserId"}, - {501, nullptr, "RegisterAppletResourceUserId"}, - {502, nullptr, "UnregisterAppletResourceUserId"}, - {503, nullptr, "EnableAppletToGetInput"}, + {501, &IHidSystemServer::RegisterAppletResourceUserId, "RegisterAppletResourceUserId"}, + {502, &IHidSystemServer::UnregisterAppletResourceUserId, "UnregisterAppletResourceUserId"}, + {503, &IHidSystemServer::EnableAppletToGetInput, "EnableAppletToGetInput"}, {504, nullptr, "SetAruidValidForVibration"}, - {505, nullptr, "EnableAppletToGetSixAxisSensor"}, - {506, nullptr, "EnableAppletToGetPadInput"}, - {507, nullptr, "EnableAppletToGetTouchScreen"}, + {505, &IHidSystemServer::EnableAppletToGetSixAxisSensor, "EnableAppletToGetSixAxisSensor"}, + {506, &IHidSystemServer::EnableAppletToGetPadInput, "EnableAppletToGetPadInput"}, + {507, &IHidSystemServer::EnableAppletToGetTouchScreen, "EnableAppletToGetTouchScreen"}, {510, nullptr, "SetVibrationMasterVolume"}, {511, nullptr, "GetVibrationMasterVolume"}, {512, nullptr, "BeginPermitVibrationSession"}, @@ -327,7 +329,7 @@ void IHidSystemServer::GetAppletDetailedUiType(HLERequestContext& ctx) { LOG_DEBUG(Service_HID, "called, npad_id_type={}", npad_id_type); // Spams a lot when controller applet is running - const NPad::AppletDetailedUiType detailed_ui_type = + const AppletDetailedUiType detailed_ui_type = GetResourceManager()->GetNpad()->GetAppletDetailedUiType(npad_id_type); IPC::ResponseBuilder rb{ctx, 3}; @@ -420,6 +422,129 @@ void IHidSystemServer::GetIrSensorState(HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 2}; rb.Push(ResultSuccess); } +void IHidSystemServer::RegisterAppletResourceUserId(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool enable_input; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, enable_input={}, applet_resource_user_id={}", + parameters.enable_input, parameters.applet_resource_user_id); + + Result result = GetResourceManager()->RegisterAppletResourceUserId( + parameters.applet_resource_user_id, parameters.enable_input); + + if (result.IsSuccess()) { + // result = GetResourceManager()->GetNpad()->RegisterAppletResourceUserId( + // parameters.applet_resource_user_id); + } + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + u64 applet_resource_user_id{rp.Pop<u64>()}; + + LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id); + + GetResourceManager()->UnregisterAppletResourceUserId(applet_resource_user_id); + // GetResourceManager()->GetNpad()->UnregisterAppletResourceUserId(applet_resource_user_id); + // GetResourceManager()->GetPalma()->UnregisterAppletResourceUserId(applet_resource_user_id); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetInput(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnableInput(parameters.applet_resource_user_id, parameters.is_enabled); + // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetSixAxisSensor(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnableTouchScreen(parameters.applet_resource_user_id, + parameters.is_enabled); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetPadInput(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnablePadInput(parameters.applet_resource_user_id, parameters.is_enabled); + // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetTouchScreen(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnableTouchScreen(parameters.applet_resource_user_id, + parameters.is_enabled); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} void IHidSystemServer::AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx) { LOG_INFO(Service_AM, "(STUBBED) called"); diff --git a/src/core/hle/service/hid/hid_system_server.h b/src/core/hle/service/hid/hid_system_server.h index 822d5e5b9..1e623dfc2 100644 --- a/src/core/hle/service/hid/hid_system_server.h +++ b/src/core/hle/service/hid/hid_system_server.h @@ -38,6 +38,12 @@ private: void HasLeftRightBattery(HLERequestContext& ctx); void GetUniquePadsFromNpad(HLERequestContext& ctx); void GetIrSensorState(HLERequestContext& ctx); + void RegisterAppletResourceUserId(HLERequestContext& ctx); + void UnregisterAppletResourceUserId(HLERequestContext& ctx); + void EnableAppletToGetInput(HLERequestContext& ctx); + void EnableAppletToGetSixAxisSensor(HLERequestContext& ctx); + void EnableAppletToGetPadInput(HLERequestContext& ctx); + void EnableAppletToGetTouchScreen(HLERequestContext& ctx); void AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx); void AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx); void GetRegisteredDevices(HLERequestContext& ctx); diff --git a/src/core/hle/service/hid/resource_manager.cpp b/src/core/hle/service/hid/resource_manager.cpp index e76d4eea9..6c6cbd802 100644 --- a/src/core/hle/service/hid/resource_manager.cpp +++ b/src/core/hle/service/hid/resource_manager.cpp @@ -9,6 +9,7 @@ #include "core/hle/service/hid/resource_manager.h" #include "core/hle/service/ipc_helpers.h" +#include "core/hle/service/hid/controllers/applet_resource.h" #include "core/hle/service/hid/controllers/console_six_axis.h" #include "core/hle/service/hid/controllers/debug_pad.h" #include "core/hle/service/hid/controllers/gesture.h" @@ -17,10 +18,10 @@ #include "core/hle/service/hid/controllers/npad.h" #include "core/hle/service/hid/controllers/palma.h" #include "core/hle/service/hid/controllers/seven_six_axis.h" +#include "core/hle/service/hid/controllers/shared_memory_format.h" #include "core/hle/service/hid/controllers/six_axis.h" #include "core/hle/service/hid/controllers/stubbed.h" #include "core/hle/service/hid/controllers/touchscreen.h" -#include "core/hle/service/hid/controllers/xpad.h" namespace Service::HID { @@ -33,7 +34,9 @@ constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 10 constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000}; // (5ms, 200Hz) ResourceManager::ResourceManager(Core::System& system_) - : system{system_}, service_context{system_, "hid"} {} + : system{system_}, service_context{system_, "hid"} { + applet_resource = std::make_shared<AppletResource>(system); +} ResourceManager::~ResourceManager() = default; @@ -42,41 +45,49 @@ void ResourceManager::Initialize() { return; } - u8* shared_memory = system.Kernel().GetHidSharedMem().GetPointer(); - debug_pad = std::make_shared<DebugPad>(system.HIDCore(), shared_memory); - mouse = std::make_shared<Mouse>(system.HIDCore(), shared_memory); - debug_mouse = std::make_shared<DebugMouse>(system.HIDCore(), shared_memory); - keyboard = std::make_shared<Keyboard>(system.HIDCore(), shared_memory); - unique_pad = std::make_shared<UniquePad>(system.HIDCore(), shared_memory); - npad = std::make_shared<NPad>(system.HIDCore(), shared_memory, service_context); - gesture = std::make_shared<Gesture>(system.HIDCore(), shared_memory); - touch_screen = std::make_shared<TouchScreen>(system.HIDCore(), shared_memory); - xpad = std::make_shared<XPad>(system.HIDCore(), shared_memory); + system.HIDCore().ReloadInputDevices(); + is_initialized = true; +} + +void ResourceManager::InitializeController(u64 aruid) { + SharedMemoryFormat* shared_memory = nullptr; + const auto result = applet_resource->GetSharedMemoryFormat(&shared_memory, aruid); + if (result.IsError()) { + return; + } + + debug_pad = std::make_shared<DebugPad>(system.HIDCore(), shared_memory->debug_pad); + mouse = std::make_shared<Mouse>(system.HIDCore(), shared_memory->mouse); + debug_mouse = std::make_shared<DebugMouse>(system.HIDCore(), shared_memory->debug_mouse); + keyboard = std::make_shared<Keyboard>(system.HIDCore(), shared_memory->keyboard); + unique_pad = std::make_shared<UniquePad>(system.HIDCore(), shared_memory->unique_pad.header); + npad = std::make_shared<NPad>(system.HIDCore(), shared_memory->npad, service_context); + gesture = std::make_shared<Gesture>(system.HIDCore(), shared_memory->gesture); + touch_screen = std::make_shared<TouchScreen>(system.HIDCore(), shared_memory->touch_screen); - palma = std::make_shared<Palma>(system.HIDCore(), shared_memory, service_context); + palma = std::make_shared<Palma>(system.HIDCore(), service_context); - home_button = std::make_shared<HomeButton>(system.HIDCore(), shared_memory); - sleep_button = std::make_shared<SleepButton>(system.HIDCore(), shared_memory); - capture_button = std::make_shared<CaptureButton>(system.HIDCore(), shared_memory); + home_button = std::make_shared<HomeButton>(system.HIDCore(), shared_memory->home_button.header); + sleep_button = + std::make_shared<SleepButton>(system.HIDCore(), shared_memory->sleep_button.header); + capture_button = + std::make_shared<CaptureButton>(system.HIDCore(), shared_memory->capture_button.header); + digitizer = std::make_shared<Digitizer>(system.HIDCore(), shared_memory->digitizer.header); six_axis = std::make_shared<SixAxis>(system.HIDCore(), npad); - console_six_axis = std::make_shared<ConsoleSixAxis>(system.HIDCore(), shared_memory); + console_six_axis = std::make_shared<ConsoleSixAxis>(system.HIDCore(), shared_memory->console); seven_six_axis = std::make_shared<SevenSixAxis>(system); - home_button->SetCommonHeaderOffset(0x4C00); - sleep_button->SetCommonHeaderOffset(0x4E00); - capture_button->SetCommonHeaderOffset(0x5000); - unique_pad->SetCommonHeaderOffset(0x5A00); - debug_mouse->SetCommonHeaderOffset(0x3DC00); - // Homebrew doesn't try to activate some controllers, so we activate them by default npad->Activate(); six_axis->Activate(); touch_screen->Activate(); +} - system.HIDCore().ReloadInputDevices(); - is_initialized = true; +std::shared_ptr<AppletResource> ResourceManager::GetAppletResource() const { + return applet_resource; } + std::shared_ptr<CaptureButton> ResourceManager::GetCaptureButton() const { return capture_button; } @@ -93,6 +104,10 @@ std::shared_ptr<DebugPad> ResourceManager::GetDebugPad() const { return debug_pad; } +std::shared_ptr<Digitizer> ResourceManager::GetDigitizer() const { + return digitizer; +} + std::shared_ptr<Gesture> ResourceManager::GetGesture() const { return gesture; } @@ -137,10 +152,86 @@ std::shared_ptr<UniquePad> ResourceManager::GetUniquePad() const { return unique_pad; } +Result ResourceManager::CreateAppletResource(u64 aruid) { + if (aruid == 0) { + const auto result = RegisterCoreAppletResource(); + if (result.IsError()) { + return result; + } + return GetNpad()->Activate(); + } + + const auto result = CreateAppletResourceImpl(aruid); + if (result.IsError()) { + return result; + } + return GetNpad()->Activate(aruid); +} + +Result ResourceManager::CreateAppletResourceImpl(u64 aruid) { + std::scoped_lock lock{shared_mutex}; + const auto result = applet_resource->CreateAppletResource(aruid); + if (result.IsSuccess()) { + InitializeController(aruid); + } + return result; +} + +Result ResourceManager::RegisterCoreAppletResource() { + std::scoped_lock lock{shared_mutex}; + return applet_resource->RegisterCoreAppletResource(); +} + +Result ResourceManager::UnregisterCoreAppletResource() { + std::scoped_lock lock{shared_mutex}; + return applet_resource->UnregisterCoreAppletResource(); +} + +Result ResourceManager::RegisterAppletResourceUserId(u64 aruid, bool bool_value) { + std::scoped_lock lock{shared_mutex}; + return applet_resource->RegisterAppletResourceUserId(aruid, bool_value); +} + +void ResourceManager::UnregisterAppletResourceUserId(u64 aruid) { + std::scoped_lock lock{shared_mutex}; + applet_resource->UnregisterAppletResourceUserId(aruid); +} + +Result ResourceManager::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) { + std::scoped_lock lock{shared_mutex}; + return applet_resource->GetSharedMemoryHandle(out_handle, aruid); +} + +void ResourceManager::FreeAppletResourceId(u64 aruid) { + std::scoped_lock lock{shared_mutex}; + applet_resource->FreeAppletResourceId(aruid); +} + +void ResourceManager::EnableInput(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnableInput(aruid, is_enabled); +} + +void ResourceManager::EnableSixAxisSensor(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnableSixAxisSensor(aruid, is_enabled); +} + +void ResourceManager::EnablePadInput(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnablePadInput(aruid, is_enabled); +} + +void ResourceManager::EnableTouchScreen(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnableTouchScreen(aruid, is_enabled); +} + void ResourceManager::UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) { auto& core_timing = system.CoreTiming(); debug_pad->OnUpdate(core_timing); + digitizer->OnUpdate(core_timing); unique_pad->OnUpdate(core_timing); gesture->OnUpdate(core_timing); touch_screen->OnUpdate(core_timing); @@ -148,7 +239,6 @@ void ResourceManager::UpdateControllers(std::uintptr_t user_data, home_button->OnUpdate(core_timing); sleep_button->OnUpdate(core_timing); capture_button->OnUpdate(core_timing); - xpad->OnUpdate(core_timing); } void ResourceManager::UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) { @@ -171,15 +261,15 @@ void ResourceManager::UpdateMotion(std::uintptr_t user_data, std::chrono::nanose console_six_axis->OnUpdate(core_timing); } -IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource) - : ServiceFramework{system_, "IAppletResource"} { +IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource, + u64 applet_resource_user_id) + : ServiceFramework{system_, "IAppletResource"}, aruid{applet_resource_user_id}, + resource_manager{resource} { static const FunctionInfo functions[] = { {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"}, }; RegisterHandlers(functions); - resource->Initialize(); - // Register update callbacks npad_update_event = Core::Timing::CreateEvent( "HID::UpdatePadCallback", @@ -228,14 +318,18 @@ IAppletResource::~IAppletResource() { system.CoreTiming().UnscheduleEvent(default_update_event, 0); system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event, 0); system.CoreTiming().UnscheduleEvent(motion_update_event, 0); + resource_manager->FreeAppletResourceId(aruid); } void IAppletResource::GetSharedMemoryHandle(HLERequestContext& ctx) { - LOG_DEBUG(Service_HID, "called"); + Kernel::KSharedMemory* handle; + const auto result = resource_manager->GetSharedMemoryHandle(&handle, aruid); + + LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, result=0x{:X}", aruid, result.raw); IPC::ResponseBuilder rb{ctx, 2, 1}; - rb.Push(ResultSuccess); - rb.PushCopyObjects(&system.Kernel().GetHidSharedMem()); + rb.Push(result); + rb.PushCopyObjects(handle); } } // namespace Service::HID diff --git a/src/core/hle/service/hid/resource_manager.h b/src/core/hle/service/hid/resource_manager.h index 2b6a9b5e6..5ad7cb564 100644 --- a/src/core/hle/service/hid/resource_manager.h +++ b/src/core/hle/service/hid/resource_manager.h @@ -6,11 +6,20 @@ #include "core/hle/service/kernel_helpers.h" #include "core/hle/service/service.h" +namespace Core { +class System; +} + namespace Core::Timing { struct EventType; } +namespace Kernel { +class KSharedMemory; +} + namespace Service::HID { +class AppletResource; class Controller_Stubbed; class ConsoleSixAxis; class DebugPad; @@ -22,10 +31,10 @@ class Palma; class SevenSixAxis; class SixAxis; class TouchScreen; -class XPad; using CaptureButton = Controller_Stubbed; -using DebugMouse = Controller_Stubbed; +using DebugMouse = Mouse; +using Digitizer = Controller_Stubbed; using HomeButton = Controller_Stubbed; using SleepButton = Controller_Stubbed; using UniquePad = Controller_Stubbed; @@ -37,11 +46,14 @@ public: ~ResourceManager(); void Initialize(); + void InitializeController(u64 aruid); + std::shared_ptr<AppletResource> GetAppletResource() const; std::shared_ptr<CaptureButton> GetCaptureButton() const; std::shared_ptr<ConsoleSixAxis> GetConsoleSixAxis() const; std::shared_ptr<DebugMouse> GetDebugMouse() const; std::shared_ptr<DebugPad> GetDebugPad() const; + std::shared_ptr<Digitizer> GetDigitizer() const; std::shared_ptr<Gesture> GetGesture() const; std::shared_ptr<HomeButton> GetHomeButton() const; std::shared_ptr<Keyboard> GetKeyboard() const; @@ -54,18 +66,39 @@ public: std::shared_ptr<TouchScreen> GetTouchScreen() const; std::shared_ptr<UniquePad> GetUniquePad() const; + Result CreateAppletResource(u64 aruid); + + Result RegisterCoreAppletResource(); + Result UnregisterCoreAppletResource(); + Result RegisterAppletResourceUserId(u64 aruid, bool bool_value); + void UnregisterAppletResourceUserId(u64 aruid); + + Result GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid); + void FreeAppletResourceId(u64 aruid); + + void EnableInput(u64 aruid, bool is_enabled); + void EnableSixAxisSensor(u64 aruid, bool is_enabled); + void EnablePadInput(u64 aruid, bool is_enabled); + void EnableTouchScreen(u64 aruid, bool is_enabled); + void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateMouseKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); private: + Result CreateAppletResourceImpl(u64 aruid); + bool is_initialized{false}; + mutable std::mutex shared_mutex; + std::shared_ptr<AppletResource> applet_resource = nullptr; + std::shared_ptr<CaptureButton> capture_button = nullptr; std::shared_ptr<ConsoleSixAxis> console_six_axis = nullptr; std::shared_ptr<DebugMouse> debug_mouse = nullptr; std::shared_ptr<DebugPad> debug_pad = nullptr; + std::shared_ptr<Digitizer> digitizer = nullptr; std::shared_ptr<Gesture> gesture = nullptr; std::shared_ptr<HomeButton> home_button = nullptr; std::shared_ptr<Keyboard> keyboard = nullptr; @@ -77,7 +110,6 @@ private: std::shared_ptr<SleepButton> sleep_button = nullptr; std::shared_ptr<TouchScreen> touch_screen = nullptr; std::shared_ptr<UniquePad> unique_pad = nullptr; - std::shared_ptr<XPad> xpad = nullptr; // TODO: Create these resources // std::shared_ptr<AudioControl> audio_control = nullptr; @@ -96,7 +128,8 @@ private: class IAppletResource final : public ServiceFramework<IAppletResource> { public: - explicit IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource); + explicit IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource, + u64 applet_resource_user_id); ~IAppletResource() override; private: @@ -106,6 +139,9 @@ private: std::shared_ptr<Core::Timing::EventType> default_update_event; std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event; std::shared_ptr<Core::Timing::EventType> motion_update_event; + + u64 aruid; + std::shared_ptr<ResourceManager> resource_manager; }; } // namespace Service::HID diff --git a/src/core/hle/service/hle_ipc.cpp b/src/core/hle/service/hle_ipc.cpp index ff374ae39..38955932c 100644 --- a/src/core/hle/service/hle_ipc.cpp +++ b/src/core/hle/service/hle_ipc.cpp @@ -146,8 +146,10 @@ HLERequestContext::HLERequestContext(Kernel::KernelCore& kernel_, Core::Memory:: HLERequestContext::~HLERequestContext() = default; -void HLERequestContext::ParseCommandBuffer(const Kernel::KHandleTable& handle_table, - u32_le* src_cmdbuf, bool incoming) { +void HLERequestContext::ParseCommandBuffer(Kernel::KProcess& process, u32_le* src_cmdbuf, + bool incoming) { + client_handle_table = &process.GetHandleTable(); + IPC::RequestParser rp(src_cmdbuf); command_header = rp.PopRaw<IPC::CommandHeader>(); @@ -160,7 +162,8 @@ void HLERequestContext::ParseCommandBuffer(const Kernel::KHandleTable& handle_ta if (command_header->enable_handle_descriptor) { handle_descriptor_header = rp.PopRaw<IPC::HandleDescriptorHeader>(); if (handle_descriptor_header->send_current_pid) { - pid = rp.Pop<u64>(); + pid = process.GetProcessId(); + rp.Skip(2, false); } if (incoming) { // Populate the object lists with the data in the IPC request. @@ -267,9 +270,9 @@ void HLERequestContext::ParseCommandBuffer(const Kernel::KHandleTable& handle_ta rp.Skip(1, false); // The command is actually an u64, but we don't use the high part. } -Result HLERequestContext::PopulateFromIncomingCommandBuffer( - const Kernel::KHandleTable& handle_table, u32_le* src_cmdbuf) { - ParseCommandBuffer(handle_table, src_cmdbuf, true); +Result HLERequestContext::PopulateFromIncomingCommandBuffer(Kernel::KProcess& process, + u32_le* src_cmdbuf) { + ParseCommandBuffer(process, src_cmdbuf, true); if (command_header->IsCloseCommand()) { // Close does not populate the rest of the IPC header diff --git a/src/core/hle/service/hle_ipc.h b/src/core/hle/service/hle_ipc.h index ad5259a5c..18d464c63 100644 --- a/src/core/hle/service/hle_ipc.h +++ b/src/core/hle/service/hle_ipc.h @@ -38,6 +38,7 @@ namespace Kernel { class KAutoObject; class KernelCore; class KHandleTable; +class KProcess; class KServerSession; class KThread; } // namespace Kernel @@ -75,6 +76,7 @@ protected: using SessionRequestHandlerWeakPtr = std::weak_ptr<SessionRequestHandler>; using SessionRequestHandlerPtr = std::shared_ptr<SessionRequestHandler>; +using SessionRequestHandlerFactory = std::function<SessionRequestHandlerPtr()>; /** * Manages the underlying HLE requests for a session, and whether (or not) the session should be @@ -194,8 +196,7 @@ public: } /// Populates this context with data from the requesting process/thread. - Result PopulateFromIncomingCommandBuffer(const Kernel::KHandleTable& handle_table, - u32_le* src_cmdbuf); + Result PopulateFromIncomingCommandBuffer(Kernel::KProcess& process, u32_le* src_cmdbuf); /// Writes data from this context back to the requesting process/thread. Result WriteToOutgoingCommandBuffer(Kernel::KThread& requesting_thread); @@ -358,6 +359,10 @@ public: return *thread; } + Kernel::KHandleTable& GetClientHandleTable() { + return *client_handle_table; + } + [[nodiscard]] std::shared_ptr<SessionRequestManager> GetManager() const { return manager.lock(); } @@ -373,12 +378,12 @@ public: private: friend class IPC::ResponseBuilder; - void ParseCommandBuffer(const Kernel::KHandleTable& handle_table, u32_le* src_cmdbuf, - bool incoming); + void ParseCommandBuffer(Kernel::KProcess& process, u32_le* src_cmdbuf, bool incoming); std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf; Kernel::KServerSession* server_session{}; - Kernel::KThread* thread; + Kernel::KHandleTable* client_handle_table{}; + Kernel::KThread* thread{}; std::vector<Handle> incoming_move_handles; std::vector<Handle> incoming_copy_handles; diff --git a/src/core/hle/service/jit/jit.cpp b/src/core/hle/service/jit/jit.cpp index be996870f..65851fc05 100644 --- a/src/core/hle/service/jit/jit.cpp +++ b/src/core/hle/service/jit/jit.cpp @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "core/arm/debug.h" #include "core/arm/symbols.h" #include "core/core.h" #include "core/hle/kernel/k_code_memory.h" @@ -98,8 +99,9 @@ public: if (return_value == 0) { // The callback has written to the output executable code range, // requiring an instruction cache invalidation - system.InvalidateCpuInstructionCacheRange(configuration.user_rx_memory.offset, - configuration.user_rx_memory.size); + Core::InvalidateInstructionCacheRange(process.GetPointerUnsafe(), + configuration.user_rx_memory.offset, + configuration.user_rx_memory.size); // Write back to the IPC output buffer, if provided if (ctx.CanWriteBuffer()) { 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 <memory> -#include <fmt/format.h> -#include <mbedtls/sha256.h> - -#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<u8, 0x100> public_key; // Also known as modulus - std::array<u8, 0x100> 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<u8, 0x100> 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<SegmentHeader, 3> segment_headers; - u32_le bss_size; - INSERT_PADDING_WORDS(1); - std::array<u8, 0x20> build_id; - u32_le dso_handle_offset; - INSERT_PADDING_WORDS(1); - // .apiInfo, .dynstr, .dynsym - std::array<SegmentHeader, 3> segment_headers_2; -}; -static_assert(sizeof(NROHeader) == 0x80, "NROHeader has invalid size."); - -using SHA256Hash = std::array<u8, 0x20>; - -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<DebugMonitor> { public: explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "ldr:dmnt"} { @@ -158,541 +53,12 @@ public: } }; -class RelocatableObject final : public ServiceFramework<RelocatableObject> { -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<Parameters>(); - - 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<u8> 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<SHA256Hash> 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<u64>(); - const auto nrr_address = rp.Pop<VAddr>(); - - 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<Parameters>(); - - 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<u8> 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<VAddr, NROInfo>& 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<Parameters>(); - 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<VAddr, NROInfo> nro; - std::map<VAddr, std::vector<SHA256Hash>> 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<ServerManager>(system); server_manager->RegisterNamedService("ldr:dmnt", std::make_shared<DebugMonitor>(system)); server_manager->RegisterNamedService("ldr:pm", std::make_shared<ProcessManager>(system)); server_manager->RegisterNamedService("ldr:shel", std::make_shared<Shell>(system)); - server_manager->RegisterNamedService("ldr:ro", std::make_shared<RelocatableObject>(system)); ServerManager::RunServer(std::move(server_manager)); } diff --git a/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp b/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp index d7db24f42..75bf31e32 100644 --- a/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp +++ b/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp @@ -171,6 +171,7 @@ void MakeGraphicBuffer(android::BufferQueueProducer& producer, u32 slot, u32 han buffer->height = SharedBufferHeight; buffer->stride = SharedBufferBlockLinearStride; buffer->format = SharedBufferBlockLinearFormat; + buffer->external_format = SharedBufferBlockLinearFormat; buffer->buffer_id = handle; buffer->offset = slot * SharedBufferSlotSize; ASSERT(producer.SetPreallocatedBuffer(slot, buffer) == android::Status::NoError); 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 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<ProcessMemoryRegion, 2> 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<ProcessMemoryRegion, 2> 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 <random> + +#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<u8, ModuleIdSize> 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<u8, 0x10> reserved_10; + std::array<u8, RsaKeySize> modulus; + std::array<u8, RsaKeySize> 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<NrrKind>(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<const u8*>(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<u8, 0x100> 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/server_manager.cpp b/src/core/hle/service/server_manager.cpp index e2e399534..6808247a9 100644 --- a/src/core/hle/service/server_manager.cpp +++ b/src/core/hle/service/server_manager.cpp @@ -93,13 +93,13 @@ Result ServerManager::RegisterSession(Kernel::KServerSession* session, } Result ServerManager::RegisterNamedService(const std::string& service_name, - std::shared_ptr<SessionRequestHandler>&& handler, + SessionRequestHandlerFactory&& handler_factory, u32 max_sessions) { ASSERT(m_sessions.size() + m_ports.size() < MaximumWaitObjects); // Add the new server to sm:. ASSERT(R_SUCCEEDED( - m_system.ServiceManager().RegisterService(service_name, max_sessions, handler))); + m_system.ServiceManager().RegisterService(service_name, max_sessions, handler_factory))); // Get the registered port. Kernel::KPort* port{}; @@ -112,7 +112,7 @@ Result ServerManager::RegisterNamedService(const std::string& service_name, // Begin tracking the server port. { std::scoped_lock ll{m_list_mutex}; - m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler)); + m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler_factory)); } // Signal the wakeup event. @@ -121,8 +121,18 @@ Result ServerManager::RegisterNamedService(const std::string& service_name, R_SUCCEED(); } +Result ServerManager::RegisterNamedService(const std::string& service_name, + std::shared_ptr<SessionRequestHandler>&& handler, + u32 max_sessions) { + // Make the factory. + const auto HandlerFactory = [handler]() { return handler; }; + + // Register the service with the new factory. + R_RETURN(this->RegisterNamedService(service_name, std::move(HandlerFactory), max_sessions)); +} + Result ServerManager::ManageNamedPort(const std::string& service_name, - std::shared_ptr<SessionRequestHandler>&& handler, + SessionRequestHandlerFactory&& handler_factory, u32 max_sessions) { ASSERT(m_sessions.size() + m_ports.size() < MaximumWaitObjects); @@ -149,7 +159,7 @@ Result ServerManager::ManageNamedPort(const std::string& service_name, // Begin tracking the server port. { std::scoped_lock ll{m_list_mutex}; - m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler)); + m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler_factory)); } // We succeeded. @@ -269,13 +279,13 @@ Result ServerManager::WaitAndProcessImpl() { case HandleType::Port: { // Port signaled. auto* port = wait_obj->DynamicCast<Kernel::KServerPort*>(); - std::shared_ptr<SessionRequestHandler> handler; + SessionRequestHandlerFactory handler_factory; // Remove from tracking. { std::scoped_lock ll{m_list_mutex}; ASSERT(m_ports.contains(port)); - m_ports.at(port).swap(handler); + m_ports.at(port).swap(handler_factory); m_ports.erase(port); } @@ -283,7 +293,7 @@ Result ServerManager::WaitAndProcessImpl() { sl.unlock(); // Finish. - R_RETURN(this->OnPortEvent(port, std::move(handler))); + R_RETURN(this->OnPortEvent(port, std::move(handler_factory))); } case HandleType::Session: { // Session signaled. @@ -333,19 +343,19 @@ Result ServerManager::WaitAndProcessImpl() { } Result ServerManager::OnPortEvent(Kernel::KServerPort* port, - std::shared_ptr<SessionRequestHandler>&& handler) { + SessionRequestHandlerFactory&& handler_factory) { // Accept a new server session. Kernel::KServerSession* session = port->AcceptSession(); ASSERT(session != nullptr); // Create the session manager and install the handler. auto manager = std::make_shared<SessionRequestManager>(m_system.Kernel(), *this); - manager->SetSessionHandler(std::shared_ptr(handler)); + manager->SetSessionHandler(handler_factory()); // Track the server session. { std::scoped_lock ll{m_list_mutex}; - m_ports.emplace(port, std::move(handler)); + m_ports.emplace(port, std::move(handler_factory)); m_sessions.emplace(session, std::move(manager)); } diff --git a/src/core/hle/service/server_manager.h b/src/core/hle/service/server_manager.h index 58b0a0832..c4bc07262 100644 --- a/src/core/hle/service/server_manager.h +++ b/src/core/hle/service/server_manager.h @@ -13,6 +13,7 @@ #include "common/polyfill_thread.h" #include "common/thread.h" #include "core/hle/result.h" +#include "core/hle/service/hle_ipc.h" #include "core/hle/service/mutex.h" namespace Core { @@ -28,10 +29,6 @@ class KSynchronizationObject; namespace Service { -class HLERequestContext; -class SessionRequestHandler; -class SessionRequestManager; - class ServerManager { public: explicit ServerManager(Core::System& system); @@ -40,10 +37,13 @@ public: Result RegisterSession(Kernel::KServerSession* session, std::shared_ptr<SessionRequestManager> manager); Result RegisterNamedService(const std::string& service_name, + SessionRequestHandlerFactory&& handler_factory, + u32 max_sessions = 64); + Result RegisterNamedService(const std::string& service_name, std::shared_ptr<SessionRequestHandler>&& handler, u32 max_sessions = 64); Result ManageNamedPort(const std::string& service_name, - std::shared_ptr<SessionRequestHandler>&& handler, u32 max_sessions = 64); + SessionRequestHandlerFactory&& handler_factory, u32 max_sessions = 64); Result ManageDeferral(Kernel::KEvent** out_event); Result LoopProcess(); @@ -56,7 +56,7 @@ private: Result LoopProcessImpl(); Result WaitAndProcessImpl(); - Result OnPortEvent(Kernel::KServerPort* port, std::shared_ptr<SessionRequestHandler>&& handler); + Result OnPortEvent(Kernel::KServerPort* port, SessionRequestHandlerFactory&& handler_factory); Result OnSessionEvent(Kernel::KServerSession* session, std::shared_ptr<SessionRequestManager>&& manager); Result OnDeferralEvent(std::list<RequestState>&& deferrals); @@ -68,7 +68,7 @@ private: std::mutex m_list_mutex; // Guest state tracking - std::map<Kernel::KServerPort*, std::shared_ptr<SessionRequestHandler>> m_ports{}; + std::map<Kernel::KServerPort*, SessionRequestHandlerFactory> m_ports{}; std::map<Kernel::KServerSession*, std::shared_ptr<SessionRequestManager>> m_sessions{}; Kernel::KEvent* m_event{}; Kernel::KEvent* m_deferral_event{}; 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::ServiceManager>& 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); }); diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp index 9ab718e0a..296ee6e89 100644 --- a/src/core/hle/service/sm/sm.cpp +++ b/src/core/hle/service/sm/sm.cpp @@ -51,7 +51,7 @@ static Result ValidateServiceName(const std::string& name) { } Result ServiceManager::RegisterService(std::string name, u32 max_sessions, - SessionRequestHandlerPtr handler) { + SessionRequestHandlerFactory handler) { R_TRY(ValidateServiceName(name)); std::scoped_lock lk{lock}; @@ -121,7 +121,7 @@ void SM::Initialize(HLERequestContext& ctx) { rb.Push(ResultSuccess); } -void SM::GetService(HLERequestContext& ctx) { +void SM::GetServiceCmif(HLERequestContext& ctx) { Kernel::KClientSession* client_session{}; auto result = GetServiceImpl(&client_session, ctx); if (ctx.GetIsDeferred()) { @@ -192,19 +192,32 @@ Result SM::GetServiceImpl(Kernel::KClientSession** out_client_session, HLEReques return result; } - LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId()); - *out_client_session = session; return ResultSuccess; } -void SM::RegisterService(HLERequestContext& ctx) { +void SM::RegisterServiceCmif(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; std::string name(PopServiceName(rp)); const auto is_light = static_cast<bool>(rp.PopRaw<u32>()); const auto max_session_count = rp.PopRaw<u32>(); + this->RegisterServiceImpl(ctx, name, max_session_count, is_light); +} + +void SM::RegisterServiceTipc(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + std::string name(PopServiceName(rp)); + + const auto max_session_count = rp.PopRaw<u32>(); + const auto is_light = static_cast<bool>(rp.PopRaw<u32>()); + + this->RegisterServiceImpl(ctx, name, max_session_count, is_light); +} + +void SM::RegisterServiceImpl(HLERequestContext& ctx, std::string name, u32 max_session_count, + bool is_light) { LOG_DEBUG(Service_SM, "called with name={}, max_session_count={}, is_light={}", name, max_session_count, is_light); @@ -240,15 +253,15 @@ SM::SM(ServiceManager& service_manager_, Core::System& system_) service_manager{service_manager_}, kernel{system_.Kernel()} { RegisterHandlers({ {0, &SM::Initialize, "Initialize"}, - {1, &SM::GetService, "GetService"}, - {2, &SM::RegisterService, "RegisterService"}, + {1, &SM::GetServiceCmif, "GetService"}, + {2, &SM::RegisterServiceCmif, "RegisterService"}, {3, &SM::UnregisterService, "UnregisterService"}, {4, nullptr, "DetachClient"}, }); RegisterHandlersTipc({ {0, &SM::Initialize, "Initialize"}, {1, &SM::GetServiceTipc, "GetService"}, - {2, &SM::RegisterService, "RegisterService"}, + {2, &SM::RegisterServiceTipc, "RegisterService"}, {3, &SM::UnregisterService, "UnregisterService"}, {4, nullptr, "DetachClient"}, }); @@ -264,7 +277,9 @@ void LoopProcess(Core::System& system) { server_manager->ManageDeferral(&deferral_event); service_manager.SetDeferralEvent(deferral_event); - server_manager->ManageNamedPort("sm:", std::make_shared<SM>(system.ServiceManager(), system)); + auto sm_service = std::make_shared<SM>(system.ServiceManager(), system); + server_manager->ManageNamedPort("sm:", [sm_service] { return sm_service; }); + ServerManager::RunServer(std::move(server_manager)); } diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h index 14bfaf8c2..ff74f588a 100644 --- a/src/core/hle/service/sm/sm.h +++ b/src/core/hle/service/sm/sm.h @@ -37,12 +37,15 @@ public: private: void Initialize(HLERequestContext& ctx); - void GetService(HLERequestContext& ctx); + void GetServiceCmif(HLERequestContext& ctx); void GetServiceTipc(HLERequestContext& ctx); - void RegisterService(HLERequestContext& ctx); + void RegisterServiceCmif(HLERequestContext& ctx); + void RegisterServiceTipc(HLERequestContext& ctx); void UnregisterService(HLERequestContext& ctx); Result GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx); + void RegisterServiceImpl(HLERequestContext& ctx, std::string name, u32 max_session_count, + bool is_light); ServiceManager& service_manager; Kernel::KernelCore& kernel; @@ -53,7 +56,8 @@ public: explicit ServiceManager(Kernel::KernelCore& kernel_); ~ServiceManager(); - Result RegisterService(std::string name, u32 max_sessions, SessionRequestHandlerPtr handler); + Result RegisterService(std::string name, u32 max_sessions, + SessionRequestHandlerFactory handler_factory); Result UnregisterService(const std::string& name); Result GetServicePort(Kernel::KPort** out_port, const std::string& name); @@ -64,7 +68,7 @@ public: LOG_DEBUG(Service, "Can't find service: {}", service_name); return nullptr; } - return std::static_pointer_cast<T>(service->second); + return std::static_pointer_cast<T>(service->second()); } void InvokeControlRequest(HLERequestContext& context); @@ -79,7 +83,7 @@ private: /// Map of registered services, retrieved using GetServicePort. std::mutex lock; - std::unordered_map<std::string, SessionRequestHandlerPtr> registered_services; + std::unordered_map<std::string, SessionRequestHandlerFactory> registered_services; std::unordered_map<std::string, Kernel::KPort*> service_ports; /// Kernel context diff --git a/src/core/hle/service/ssl/ssl.cpp b/src/core/hle/service/ssl/ssl.cpp index 6c8427b0d..0fbb43057 100644 --- a/src/core/hle/service/ssl/ssl.cpp +++ b/src/core/hle/service/ssl/ssl.cpp @@ -240,7 +240,7 @@ private: return ret; } - Result ReadImpl(std::vector<u8>* out_data, size_t size) { + Result ReadImpl(std::vector<u8>* out_data) { ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; }); size_t actual_size{}; Result res = backend->Read(&actual_size, *out_data); @@ -326,8 +326,8 @@ private: } void Read(HLERequestContext& ctx) { - std::vector<u8> output_bytes; - const Result res = ReadImpl(&output_bytes, ctx.GetWriteBufferSize()); + std::vector<u8> output_bytes(ctx.GetWriteBufferSize()); + const Result res = ReadImpl(&output_bytes); IPC::ResponseBuilder rb{ctx, 3}; rb.Push(res); if (res == ResultSuccess) { diff --git a/src/core/memory.cpp b/src/core/memory.cpp index 5b376b202..169bf4c8c 100644 --- a/src/core/memory.cpp +++ b/src/core/memory.cpp @@ -43,13 +43,9 @@ bool AddressSpaceContains(const Common::PageTable& table, const Common::ProcessA struct Memory::Impl { explicit Impl(Core::System& system_) : system{system_} {} - void SetCurrentPageTable(Kernel::KProcess& process, u32 core_id) { + void SetCurrentPageTable(Kernel::KProcess& process) { current_page_table = &process.GetPageTable().GetImpl(); current_page_table->fastmem_arena = system.DeviceMemory().buffer.VirtualBasePointer(); - - const std::size_t address_space_width = process.GetPageTable().GetAddressSpaceWidth(); - - system.ArmInterface(core_id).PageTableChanged(*current_page_table, address_space_width); } void MapMemoryRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size, @@ -871,8 +867,8 @@ void Memory::Reset() { impl = std::make_unique<Impl>(system); } -void Memory::SetCurrentPageTable(Kernel::KProcess& process, u32 core_id) { - impl->SetCurrentPageTable(process, core_id); +void Memory::SetCurrentPageTable(Kernel::KProcess& process) { + impl->SetCurrentPageTable(process); } void Memory::MapMemoryRegion(Common::PageTable& page_table, Common::ProcessAddress base, u64 size, diff --git a/src/core/memory.h b/src/core/memory.h index ed8ebb5eb..c1879e78f 100644 --- a/src/core/memory.h +++ b/src/core/memory.h @@ -73,7 +73,7 @@ public: * * @param process The process to use the page table of. */ - void SetCurrentPageTable(Kernel::KProcess& process, u32 core_id); + void SetCurrentPageTable(Kernel::KProcess& process); /** * Maps an allocated buffer onto a region of the emulated process address space. diff --git a/src/core/memory/cheat_engine.cpp b/src/core/memory/cheat_engine.cpp index db30ba598..3fc4024dc 100644 --- a/src/core/memory/cheat_engine.cpp +++ b/src/core/memory/cheat_engine.cpp @@ -62,7 +62,7 @@ u64 StandardVmCallbacks::HidKeysDown() { } const auto applet_resource = hid->GetResourceManager(); - if (applet_resource == nullptr) { + if (applet_resource == nullptr || applet_resource->GetNpad() == nullptr) { LOG_WARNING(CheatEngine, "Attempted to read input state, but applet resource is not initialized!"); return 0; diff --git a/src/core/reporter.cpp b/src/core/reporter.cpp index 5d168cbc1..dc3883528 100644 --- a/src/core/reporter.cpp +++ b/src/core/reporter.cpp @@ -109,41 +109,11 @@ json GetProcessorStateData(const std::string& architecture, u64 entry_point, u64 return out; } -json GetProcessorStateDataAuto(Core::System& system) { - const auto* process{system.ApplicationProcess()}; - auto& arm{system.CurrentArmInterface()}; - - Core::ARM_Interface::ThreadContext64 context{}; - arm.SaveContext(context); - - return GetProcessorStateData(process->Is64Bit() ? "AArch64" : "AArch32", - GetInteger(process->GetEntryPoint()), context.sp, context.pc, - context.pstate, context.cpu_registers); -} - -json GetBacktraceData(Core::System& system) { - auto out = json::array(); - const auto& backtrace{system.CurrentArmInterface().GetBacktrace()}; - for (const auto& entry : backtrace) { - out.push_back({ - {"module", entry.module}, - {"address", fmt::format("{:016X}", entry.address)}, - {"original_address", fmt::format("{:016X}", entry.original_address)}, - {"offset", fmt::format("{:016X}", entry.offset)}, - {"symbol_name", entry.name}, - }); - } - - return out; -} - json GetFullDataAuto(const std::string& timestamp, u64 title_id, Core::System& system) { json out; out["yuzu_version"] = GetYuzuVersionData(); out["report_common"] = GetReportCommonData(title_id, ResultSuccess, timestamp); - out["processor_state"] = GetProcessorStateDataAuto(system); - out["backtrace"] = GetBacktraceData(system); return out; } @@ -351,8 +321,6 @@ void Reporter::SaveErrorReport(u64 title_id, Result result, out["yuzu_version"] = GetYuzuVersionData(); out["report_common"] = GetReportCommonData(title_id, result, timestamp); - out["processor_state"] = GetProcessorStateDataAuto(system); - out["backtrace"] = GetBacktraceData(system); out["error_custom_text"] = { {"main", custom_text_main.value_or("")}, |