dmnt: refactor to use sts:: namespace.

stratosphere/dmnt/source/cheat/impl/dmnt_cheat_api.hpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <stratosphere.hpp>
+#include <stratosphere/dmnt.hpp>
+
+namespace sts::dmnt::cheat::impl {
+
+    bool GetHasActiveCheatProcess();
+    Handle GetCheatProcessEventHandle();
+    Result GetCheatProcessMetadata(CheatProcessMetadata *out);
+    Result ForceOpenCheatProcess();
+
+    Result ReadCheatProcessMemoryUnsafe(u64 process_addr, void *out_data, size_t size);
+    Result WriteCheatProcessMemoryUnsafe(u64 process_addr, void *data, size_t size);
+
+    Result GetCheatProcessMappingCount(u64 *out_count);
+    Result GetCheatProcessMappings(MemoryInfo *mappings, size_t max_count, u64 *out_count, u64 offset);
+    Result ReadCheatProcessMemory(u64 proc_addr, void *out_data, size_t size);
+    Result WriteCheatProcessMemory(u64 proc_addr, const void *data, size_t size);
+    Result QueryCheatProcessMemory(MemoryInfo *mapping, u64 address);
+
+    Result GetCheatCount(u64 *out_count);
+    Result GetCheats(CheatEntry *cheats, size_t max_count, u64 *out_count, u64 offset);
+    Result GetCheatById(CheatEntry *out_cheat, u32 cheat_id);
+    Result ToggleCheat(u32 cheat_id);
+    Result AddCheat(u32 *out_id, const CheatDefinition *def, bool enabled);
+    Result RemoveCheat(u32 cheat_id);
+
+    Result GetFrozenAddressCount(u64 *out_count);
+    Result GetFrozenAddresses(FrozenAddressEntry *frz_addrs, size_t max_count, u64 *out_count, u64 offset);
+    Result GetFrozenAddress(FrozenAddressEntry *frz_addr, u64 address);
+    Result EnableFrozenAddress(u64 *out_value, u64 address, u64 width);
+    Result DisableFrozenAddress(u64 address);
+
+}

stratosphere/dmnt/source/cheat/impl/dmnt_cheat_debug_events_manager.cpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dmnt_cheat_debug_events_manager.hpp"
+
+/* WORKAROUND: This design prevents a kernel deadlock from occurring on 6.0.0+ */
+
+namespace sts::dmnt::cheat::impl {
+
+    namespace {
+
+        class DebugEventsManager {
+            public:
+                static constexpr size_t NumCores = 4;
+            private:
+                HosMessageQueue message_queues[NumCores];
+                HosThread threads[NumCores];
+                HosSignal continued_signal;
+            private:
+                static void PerCoreThreadFunction(void *_this) {
+                    /* This thread will wait on the appropriate message queue. */
+                    DebugEventsManager *this_ptr = reinterpret_cast<DebugEventsManager *>(_this);
+                    const u32 current_core = svcGetCurrentProcessorNumber();
+                    while (true) {
+                        /* Receive handle. */
+                        Handle debug_handle = this_ptr->WaitReceiveHandle(current_core);
+
+                        /* Continue events on the correct core. */
+                        R_ASSERT(this_ptr->ContinueDebugEvent(debug_handle));
+
+                        /* Signal that we've continued. */
+                        this_ptr->SignalContinued();
+                    }
+                }
+
+                u32 GetTargetCore(const svc::DebugEventInfo &dbg_event, Handle debug_handle) {
+                    /* If we don't need to continue on a specific core, use the system core. */
+                    u32 target_core = NumCores - 1;
+
+                    /* Retrieve correct core for new thread event. */
+                    if (dbg_event.type == svc::DebugEventType::AttachThread) {
+                        u64 out64 = 0;
+                        u32 out32 = 0;
+                        R_ASSERT(svcGetDebugThreadParam(&out64, &out32, debug_handle, dbg_event.info.attach_thread.thread_id, DebugThreadParam_CurrentCore));
+                        target_core = out32;
+                    }
+
+                    return target_core;
+                }
+
+                void SendHandle(const svc::DebugEventInfo &dbg_event, Handle debug_handle) {
+                    this->message_queues[GetTargetCore(dbg_event, debug_handle)].Send(static_cast<uintptr_t>(debug_handle));
+                }
+
+                Handle WaitReceiveHandle(u32 core_id) {
+                    uintptr_t x = 0;
+                    this->message_queues[core_id].Receive(&x);
+                    return static_cast<Handle>(x);
+                }
+
+                Result ContinueDebugEvent(Handle debug_handle) {
+                    if (GetRuntimeFirmwareVersion() >= FirmwareVersion_300) {
+                        return svcContinueDebugEvent(debug_handle, 5, nullptr, 0);
+                    } else {
+                        return svcLegacyContinueDebugEvent(debug_handle, 5, 0);
+                    }
+                }
+
+                void WaitContinued() {
+                    this->continued_signal.Wait();
+                    this->continued_signal.Reset();
+                }
+
+                void SignalContinued() {
+                    this->continued_signal.Signal();
+                }
+
+            public:
+                DebugEventsManager() : message_queues{HosMessageQueue(1), HosMessageQueue(1), HosMessageQueue(1), HosMessageQueue(1)} {
+                    for (size_t i = 0; i < NumCores; i++) {
+                        /* Create thread. */
+                        R_ASSERT(this->threads[i].Initialize(&DebugEventsManager::PerCoreThreadFunction, reinterpret_cast<void *>(this), 0x1000, 24, i));
+
+                        /* Set core mask. */
+                        R_ASSERT(svcSetThreadCoreMask(this->threads[i].GetHandle(), i, (1u << i)));
+
+                        /* Start thread. */
+                        R_ASSERT(this->threads[i].Start());
+                    }
+                }
+
+                void ContinueCheatProcess(Handle cheat_dbg_hnd) {
+                    /* Loop getting all debug events. */
+                    svc::DebugEventInfo d;
+                    while (R_SUCCEEDED(svcGetDebugEvent(reinterpret_cast<u8 *>(&d), cheat_dbg_hnd))) {
+                        /* ... */
+                    }
+
+                    /* Send handle to correct core, wait for continue to finish. */
+                    this->SendHandle(d, cheat_dbg_hnd);
+                    this->WaitContinued();
+                }
+        };
+
+        /* Manager global. */
+        DebugEventsManager g_events_manager;
+
+    }
+
+    void ContinueCheatProcess(Handle cheat_dbg_hnd) {
+        g_events_manager.ContinueCheatProcess(cheat_dbg_hnd);
+    }
+
+}

stratosphere/dmnt/source/cheat/impl/dmnt_cheat_debug_events_manager.hpp

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <switch.h>
+#include <stratosphere.hpp>
+
+namespace sts::dmnt::cheat::impl {
+
+    void ContinueCheatProcess(Handle cheat_dbg_hnd);
+
+}

stratosphere/dmnt/source/cheat/impl/dmnt_cheat_vm.hpp

@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <stdarg.h>
+#include <stratosphere.hpp>
+#include <stratosphere/dmnt.hpp>
+
+namespace sts::dmnt::cheat::impl {
+
+    enum CheatVmOpcodeType : u32 {
+        CheatVmOpcodeType_StoreStatic = 0,
+        CheatVmOpcodeType_BeginConditionalBlock = 1,
+        CheatVmOpcodeType_EndConditionalBlock = 2,
+        CheatVmOpcodeType_ControlLoop = 3,
+        CheatVmOpcodeType_LoadRegisterStatic = 4,
+        CheatVmOpcodeType_LoadRegisterMemory = 5,
+        CheatVmOpcodeType_StoreStaticToAddress = 6,
+        CheatVmOpcodeType_PerformArithmeticStatic = 7,
+        CheatVmOpcodeType_BeginKeypressConditionalBlock = 8,
+
+        /* These are not implemented by Gateway's VM. */
+        CheatVmOpcodeType_PerformArithmeticRegister = 9,
+        CheatVmOpcodeType_StoreRegisterToAddress = 10,
+        CheatVmOpcodeType_Reserved11 = 11,
+
+        /* This is a meta entry, and not a real opcode. */
+        /* This is to facilitate multi-nybble instruction decoding. */
+        CheatVmOpcodeType_ExtendedWidth = 12,
+
+        /* Extended width opcodes. */
+        CheatVmOpcodeType_BeginRegisterConditionalBlock = 0xC0,
+        CheatVmOpcodeType_SaveRestoreRegister = 0xC1,
+        CheatVmOpcodeType_SaveRestoreRegisterMask = 0xC2,
+
+        /* This is a meta entry, and not a real opcode. */
+        /* This is to facilitate multi-nybble instruction decoding. */
+        CheatVmOpcodeType_DoubleExtendedWidth = 0xF0,
+
+        /* Double-extended width opcodes. */
+        CheatVmOpcodeType_DebugLog = 0xFFF,
+    };
+
+    enum MemoryAccessType : u32 {
+        MemoryAccessType_MainNso = 0,
+        MemoryAccessType_Heap = 1,
+    };
+
+    enum ConditionalComparisonType : u32 {
+        ConditionalComparisonType_GT = 1,
+        ConditionalComparisonType_GE = 2,
+        ConditionalComparisonType_LT = 3,
+        ConditionalComparisonType_LE = 4,
+        ConditionalComparisonType_EQ = 5,
+        ConditionalComparisonType_NE = 6,
+    };
+
+    enum RegisterArithmeticType : u32 {
+        RegisterArithmeticType_Addition = 0,
+        RegisterArithmeticType_Subtraction = 1,
+        RegisterArithmeticType_Multiplication = 2,
+        RegisterArithmeticType_LeftShift = 3,
+        RegisterArithmeticType_RightShift = 4,
+
+        /* These are not supported by Gateway's VM. */
+        RegisterArithmeticType_LogicalAnd = 5,
+        RegisterArithmeticType_LogicalOr = 6,
+        RegisterArithmeticType_LogicalNot = 7,
+        RegisterArithmeticType_LogicalXor = 8,
+
+        RegisterArithmeticType_None = 9,
+    };
+
+    enum StoreRegisterOffsetType : u32 {
+        StoreRegisterOffsetType_None = 0,
+        StoreRegisterOffsetType_Reg = 1,
+        StoreRegisterOffsetType_Imm = 2,
+        StoreRegisterOffsetType_MemReg = 3,
+        StoreRegisterOffsetType_MemImm = 4,
+        StoreRegisterOffsetType_MemImmReg = 5,
+    };
+
+    enum CompareRegisterValueType : u32 {
+        CompareRegisterValueType_MemoryRelAddr = 0,
+        CompareRegisterValueType_MemoryOfsReg = 1,
+        CompareRegisterValueType_RegisterRelAddr = 2,
+        CompareRegisterValueType_RegisterOfsReg = 3,
+        CompareRegisterValueType_StaticValue = 4,
+        CompareRegisterValueType_OtherRegister = 5,
+    };
+
+    enum SaveRestoreRegisterOpType : u32 {
+        SaveRestoreRegisterOpType_Restore = 0,
+        SaveRestoreRegisterOpType_Save = 1,
+        SaveRestoreRegisterOpType_ClearSaved = 2,
+        SaveRestoreRegisterOpType_ClearRegs = 3,
+    };
+
+    enum DebugLogValueType : u32 {
+        DebugLogValueType_MemoryRelAddr = 0,
+        DebugLogValueType_MemoryOfsReg = 1,
+        DebugLogValueType_RegisterRelAddr = 2,
+        DebugLogValueType_RegisterOfsReg = 3,
+        DebugLogValueType_RegisterValue = 4,
+    };
+
+    union VmInt {
+        u8  bit8;
+        u16 bit16;
+        u32 bit32;
+        u64 bit64;
+    };
+
+    struct StoreStaticOpcode {
+        u32 bit_width;
+        MemoryAccessType mem_type;
+        u32 offset_register;
+        u64 rel_address;
+        VmInt value;
+    };
+
+    struct BeginConditionalOpcode {
+        u32 bit_width;
+        MemoryAccessType mem_type;
+        ConditionalComparisonType cond_type;
+        u64 rel_address;
+        VmInt value;
+    };
+
+    struct EndConditionalOpcode {};
+
+    struct ControlLoopOpcode {
+        bool start_loop;
+        u32 reg_index;
+        u32 num_iters;
+    };
+
+    struct LoadRegisterStaticOpcode {
+        u32 reg_index;
+        u64 value;
+    };
+
+    struct LoadRegisterMemoryOpcode {
+        u32 bit_width;
+        MemoryAccessType mem_type;
+        u32 reg_index;
+        bool load_from_reg;
+        u64 rel_address;
+    };
+
+    struct StoreStaticToAddressOpcode {
+        u32 bit_width;
+        u32 reg_index;
+        bool increment_reg;
+        bool add_offset_reg;
+        u32 offset_reg_index;
+        u64 value;
+    };
+
+    struct PerformArithmeticStaticOpcode {
+        u32 bit_width;
+        u32 reg_index;
+        RegisterArithmeticType math_type;
+        u32 value;
+    };
+
+    struct BeginKeypressConditionalOpcode {
+        u32 key_mask;
+    };
+
+    struct PerformArithmeticRegisterOpcode {
+        u32 bit_width;
+        RegisterArithmeticType math_type;
+        u32 dst_reg_index;
+        u32 src_reg_1_index;
+        u32 src_reg_2_index;
+        bool has_immediate;
+        VmInt value;
+    };
+
+    struct StoreRegisterToAddressOpcode {
+        u32 bit_width;
+        u32 str_reg_index;
+        u32 addr_reg_index;
+        bool increment_reg;
+        StoreRegisterOffsetType ofs_type;
+        MemoryAccessType mem_type;
+        u32 ofs_reg_index;
+        u64 rel_address;
+    };
+
+    struct BeginRegisterConditionalOpcode {
+        u32 bit_width;
+        ConditionalComparisonType cond_type;
+        u32 val_reg_index;
+        CompareRegisterValueType comp_type;
+        MemoryAccessType mem_type;
+        u32 addr_reg_index;
+        u32 other_reg_index;
+        u32 ofs_reg_index;
+        u64 rel_address;
+        VmInt value;
+    };
+
+    struct SaveRestoreRegisterOpcode {
+        u32 dst_index;
+        u32 src_index;
+        SaveRestoreRegisterOpType op_type;
+    };
+
+    struct SaveRestoreRegisterMaskOpcode {
+        SaveRestoreRegisterOpType op_type;
+        bool should_operate[0x10];
+    };
+
+    struct DebugLogOpcode {
+        u32 bit_width;
+        u32 log_id;
+        DebugLogValueType val_type;
+        MemoryAccessType mem_type;
+        u32 addr_reg_index;
+        u32 val_reg_index;
+        u32 ofs_reg_index;
+        u64 rel_address;
+    };
+
+    struct CheatVmOpcode {
+        CheatVmOpcodeType opcode;
+        bool begin_conditional_block;
+        union {
+            StoreStaticOpcode store_static;
+            BeginConditionalOpcode begin_cond;
+            EndConditionalOpcode end_cond;
+            ControlLoopOpcode ctrl_loop;
+            LoadRegisterStaticOpcode ldr_static;
+            LoadRegisterMemoryOpcode ldr_memory;
+            StoreStaticToAddressOpcode str_static;
+            PerformArithmeticStaticOpcode perform_math_static;
+            BeginKeypressConditionalOpcode begin_keypress_cond;
+            PerformArithmeticRegisterOpcode perform_math_reg;
+            StoreRegisterToAddressOpcode str_register;
+            BeginRegisterConditionalOpcode begin_reg_cond;
+            SaveRestoreRegisterOpcode save_restore_reg;
+            SaveRestoreRegisterMaskOpcode save_restore_regmask;
+            DebugLogOpcode debug_log;
+        };
+    };
+
+    class CheatVirtualMachine {
+        public:
+            constexpr static size_t MaximumProgramOpcodeCount = 0x400;
+            constexpr static size_t NumRegisters = 0x10;
+        private:
+            size_t num_opcodes = 0;
+            size_t instruction_ptr = 0;
+            size_t condition_depth = 0;
+            bool decode_success = false;
+            u32 program[MaximumProgramOpcodeCount] = {0};
+            u64 registers[NumRegisters] = {0};
+            u64 saved_values[NumRegisters] = {0};
+            size_t loop_tops[NumRegisters] = {0};
+        private:
+            bool DecodeNextOpcode(CheatVmOpcode *out);
+            void SkipConditionalBlock();
+            void ResetState();
+
+            /* For implementing the DebugLog opcode. */
+            void DebugLog(u32 log_id, u64 value);
+
+            /* For debugging. These will be IFDEF'd out normally. */
+            void OpenDebugLogFile();
+            void CloseDebugLogFile();
+            void LogToDebugFile(const char *format, ...);
+            void LogOpcode(const CheatVmOpcode *opcode);
+
+            static u64 GetVmInt(VmInt value, u32 bit_width);
+            static u64 GetCheatProcessAddress(const CheatProcessMetadata* metadata, MemoryAccessType mem_type, u64 rel_address);
+        public:
+            CheatVirtualMachine() { }
+
+            size_t GetProgramSize() {
+                return this->num_opcodes;
+            }
+
+            bool LoadProgram(const CheatEntry *cheats, size_t num_cheats);
+            void Execute(const CheatProcessMetadata *metadata);
+    #ifdef DMNT_CHEAT_VM_DEBUG_LOG
+        private:
+            FILE *debug_log_file = NULL;
+    #endif
+    };
+
+}