service: dmnt: Implement cheat manager and interface

src/common/settings.h

@@ -140,7 +140,7 @@ struct Values {
                                                Category::LibraryApplet};
     Setting<AppletMode> data_erase_applet_mode{linkage, AppletMode::HLE, "data_erase_applet_mode",
                                                Category::LibraryApplet};
-    Setting<AppletMode> error_applet_mode{linkage, AppletMode::LLE, "error_applet_mode",
+    Setting<AppletMode> error_applet_mode{linkage, AppletMode::HLE, "error_applet_mode",
                                           Category::LibraryApplet};
     Setting<AppletMode> net_connect_applet_mode{linkage, AppletMode::HLE, "net_connect_applet_mode",
                                                 Category::LibraryApplet};
@@ -435,6 +435,8 @@ struct Values {
         linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
     Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
                                           Category::RendererDebug};
+    // TODO: remove this once AMDVLK supports VK_EXT_depth_bias_control
+    bool renderer_amdvlk_depth_bias_workaround{};
     Setting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
                                          Category::RendererDebug};
 

src/core/CMakeLists.txt

@@ -590,6 +590,18 @@ add_library(core STATIC
     hle/service/caps/caps_u.h
     hle/service/cmif_serialization.h
     hle/service/cmif_types.h
+    hle/service/dmnt/cheat_interface.cpp
+    hle/service/dmnt/cheat_interface.h
+    hle/service/dmnt/cheat_parser.cpp
+    hle/service/dmnt/cheat_parser.h
+    hle/service/dmnt/cheat_process_manager.cpp
+    hle/service/dmnt/cheat_process_manager.h
+    hle/service/dmnt/cheat_virtual_machine.cpp
+    hle/service/dmnt/cheat_virtual_machine.h
+    hle/service/dmnt/dmnt.cpp
+    hle/service/dmnt/dmnt.h
+    hle/service/dmnt/dmnt_results.h
+    hle/service/dmnt/dmnt_types.h
     hle/service/erpt/erpt.cpp
     hle/service/erpt/erpt.h
     hle/service/es/es.cpp
@@ -668,10 +680,6 @@ add_library(core STATIC
     hle/service/glue/time/worker.h
     hle/service/grc/grc.cpp
     hle/service/grc/grc.h
-    hle/service/hid/active_vibration_device_list.cpp
-    hle/service/hid/active_vibration_device_list.h
-    hle/service/hid/applet_resource.cpp
-    hle/service/hid/applet_resource.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
     hle/service/hid/hid_debug_server.cpp
@@ -1051,12 +1059,9 @@ add_library(core STATIC
     hle/service/spl/spl_module.h
     hle/service/spl/spl_results.h
     hle/service/spl/spl_types.h
-    hle/service/ssl/cert_store.cpp
-    hle/service/ssl/cert_store.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
     hle/service/ssl/ssl_backend.h
-    hle/service/ssl/ssl_types.h
     hle/service/usb/usb.cpp
     hle/service/usb/usb.h
     hle/service/vi/application_display_service.cpp
@@ -1116,11 +1121,6 @@ add_library(core STATIC
     loader/xci.h
     memory.cpp
     memory.h
-    memory/cheat_engine.cpp
-    memory/cheat_engine.h
-    memory/dmnt_cheat_types.h
-    memory/dmnt_cheat_vm.cpp
-    memory/dmnt_cheat_vm.h
     perf_stats.cpp
     perf_stats.h
     precompiled_headers.h

src/core/core.cpp

@@ -39,6 +39,7 @@
 #include "core/hle/service/am/applet_manager.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/apm/apm_controller.h"
+#include "core/hle/service/dmnt/cheat_process_manager.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/glue/glue_manager.h"
 #include "core/hle/service/glue/time/static.h"
@@ -53,7 +54,6 @@
 #include "core/internal_network/network.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
-#include "core/memory/cheat_engine.h"
 #include "core/perf_stats.h"
 #include "core/reporter.h"
 #include "core/telemetry_session.h"
@@ -361,6 +361,11 @@ struct System::Impl {
         Kernel::KProcess::Register(system.Kernel(), main_process);
         kernel.AppendNewProcess(main_process);
         kernel.MakeApplicationProcess(main_process);
+
+        if (!cheat_manager) {
+            cheat_manager = std::make_unique<Service::DMNT::CheatProcessManager>(system);
+        }
+
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
@@ -382,11 +387,6 @@ struct System::Impl {
         AddGlueRegistrationForProcess(*app_loader, *main_process);
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
 
-        // Initialize cheat engine
-        if (cheat_engine) {
-            cheat_engine->Initialize();
-        }
-
         // Register with applet manager.
         applet_manager.CreateAndInsertByFrontendAppletParameters(main_process->GetProcessId(),
                                                                  params);
@@ -425,6 +425,11 @@ struct System::Impl {
             room_member->SendGameInfo(game_info);
         }
 
+        // Workarounds:
+        // Activate this in Super Smash Brothers Ultimate, it only affects AMD cards using AMDVLK
+        Settings::values.renderer_amdvlk_depth_bias_workaround =
+            params.program_id == 0x1006A800016E000ULL;
+
         status = SystemResultStatus::Success;
         return status;
     }
@@ -465,7 +470,7 @@ struct System::Impl {
         services.reset();
         service_manager.reset();
         fs_controller.Reset();
-        cheat_engine.reset();
+        cheat_manager.reset();
         telemetry_session.reset();
         core_timing.ClearPendingEvents();
         app_loader.reset();
@@ -484,6 +489,9 @@ struct System::Impl {
             room_member->SendGameInfo(game_info);
         }
 
+        // Workarounds
+        Settings::values.renderer_amdvlk_depth_bias_workaround = false;
+
         LOG_DEBUG(Core, "Shutdown OK");
     }
 
@@ -565,7 +573,7 @@ struct System::Impl {
     bool nvdec_active{};
 
     Reporter reporter;
-    std::unique_ptr<Memory::CheatEngine> cheat_engine;
+    std::unique_ptr<Service::DMNT::CheatProcessManager> cheat_manager;
     std::unique_ptr<Tools::Freezer> memory_freezer;
     std::array<u8, 0x20> build_id{};
 
@@ -871,11 +879,20 @@ FileSys::VirtualFilesystem System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
-void System::RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
+void System::RegisterCheatList(std::span<const Service::DMNT::CheatEntry> list,
                                const std::array<u8, 32>& build_id, u64 main_region_begin,
                                u64 main_region_size) {
-    impl->cheat_engine = std::make_unique<Memory::CheatEngine>(*this, list, build_id);
-    impl->cheat_engine->SetMainMemoryParameters(main_region_begin, main_region_size);
+    impl->cheat_manager->AttachToApplicationProcess(build_id, main_region_begin, main_region_size);
+
+    // Register cheat list
+    for (const auto& cheat : list) {
+        if (cheat.cheat_id == 0) {
+            impl->cheat_manager->SetMasterCheat(cheat.definition);
+            continue;
+        }
+        u32 cheat_id{};
+        impl->cheat_manager->AddCheat(cheat_id, cheat.enabled, cheat.definition);
+    }
 }
 
 void System::SetFrontendAppletSet(Service::AM::Frontend::FrontendAppletSet&& set) {
@@ -1025,6 +1042,14 @@ const Core::Debugger& System::GetDebugger() const {
     return *impl->debugger;
 }
 
+Service::DMNT::CheatProcessManager& System::GetCheatManager() {
+    return *impl->cheat_manager;
+}
+
+const Service::DMNT::CheatProcessManager& System::GetCheatManager() const {
+    return *impl->cheat_manager;
+}
+
 Network::RoomNetwork& System::GetRoomNetwork() {
     return impl->room_network;
 }

src/core/core.h

@@ -40,7 +40,6 @@ enum class ResultStatus : u16;
 } // namespace Loader
 
 namespace Core::Memory {
-struct CheatEntry;
 class Memory;
 } // namespace Core::Memory
 
@@ -64,6 +63,11 @@ namespace APM {
 class Controller;
 }
 
+namespace DMNT {
+struct CheatEntry;
+class CheatProcessManager;
+} // namespace DMNT
+
 namespace FileSystem {
 class FileSystemController;
 } // namespace FileSystem
@@ -345,7 +349,7 @@ public:
 
     [[nodiscard]] FileSys::VirtualFilesystem GetFilesystem() const;
 
-    void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
+    void RegisterCheatList(std::span<const Service::DMNT::CheatEntry> list,
                            const std::array<u8, 0x20>& build_id, u64 main_region_begin,
                            u64 main_region_size);
 
@@ -387,6 +391,9 @@ public:
     [[nodiscard]] Core::Debugger& GetDebugger();
     [[nodiscard]] const Core::Debugger& GetDebugger() const;
 
+    [[nodiscard]] Service::DMNT::CheatProcessManager& GetCheatManager();
+    [[nodiscard]] const Service::DMNT::CheatProcessManager& GetCheatManager() const;
+
     /// Gets a mutable reference to the Room Network.
     [[nodiscard]] Network::RoomNetwork& GetRoomNetwork();
 

src/core/file_sys/fssystem/fssystem_aes_xts_storage.cpp

@@ -31,8 +31,8 @@ AesXtsStorage::AesXtsStorage(VirtualFile base, const void* key1, const void* key
     ASSERT(iv_size == IvSize);
     ASSERT(Common::IsAligned(m_block_size, AesBlockSize));
 
-    std::memcpy(m_key.data() + 0, key1, KeySize / 2);
-    std::memcpy(m_key.data() + 0x10, key2, KeySize / 2);
+    std::memcpy(m_key.data() + 0, key1, KeySize);
+    std::memcpy(m_key.data() + 0x10, key2, KeySize);
     std::memcpy(m_iv.data(), iv, IvSize);
 
     m_cipher.emplace(m_key, Core::Crypto::Mode::XTS);

src/core/file_sys/patch_manager.cpp

@@ -24,12 +24,13 @@
 #include "core/file_sys/vfs/vfs_cached.h"
 #include "core/file_sys/vfs/vfs_layered.h"
 #include "core/file_sys/vfs/vfs_vector.h"
+#include "core/hle/service/dmnt/cheat_parser.h"
+#include "core/hle/service/dmnt/dmnt_types.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/set/settings_server.h"
 #include "core/loader/loader.h"
 #include "core/loader/nso.h"
-#include "core/memory/cheat_engine.h"
 
 namespace FileSys {
 namespace {
@@ -79,7 +80,7 @@ VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name)
 #endif
 }
 
-std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
+std::optional<std::vector<Service::DMNT::CheatEntry>> ReadCheatFileFromFolder(
     u64 title_id, const PatchManager::BuildID& build_id_, const VirtualDir& base_path, bool upper) {
     const auto build_id_raw = Common::HexToString(build_id_, upper);
     const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
@@ -98,7 +99,7 @@ std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
         return std::nullopt;
     }
 
-    const Core::Memory::TextCheatParser parser;
+    const Service::DMNT::CheatParser parser;
     return parser.Parse(std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
 }
 
@@ -313,7 +314,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
     return !CollectPatches(patch_dirs, build_id).empty();
 }
 
-std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
+std::vector<Service::DMNT::CheatEntry> PatchManager::CreateCheatList(
     const BuildID& build_id_) const {
     const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
@@ -326,7 +327,7 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
 
-    std::vector<Core::Memory::CheatEntry> out;
+    std::vector<Service::DMNT::CheatEntry> out;
     for (const auto& subdir : patch_dirs) {
         if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
             continue;

src/core/file_sys/patch_manager.h

@@ -10,7 +10,7 @@
 #include "common/common_types.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/vfs/vfs_types.h"
-#include "core/memory/dmnt_cheat_types.h"
+#include "core/hle/service/dmnt/dmnt_types.h"
 
 namespace Core {
 class System;
@@ -20,6 +20,10 @@ namespace Service::FileSystem {
 class FileSystemController;
 }
 
+namespace Service::DMNT {
+struct CheatEntry;
+}
+
 namespace FileSys {
 
 class ContentProvider;
@@ -65,7 +69,7 @@ public:
     [[nodiscard]] bool HasNSOPatch(const BuildID& build_id, std::string_view name) const;
 
     // Creates a CheatList object with all
-    [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(
+    [[nodiscard]] std::vector<Service::DMNT::CheatEntry> CreateCheatList(
         const BuildID& build_id) const;
 
     // Currently tracked RomFS patches:

src/core/hle/service/acc/acc.cpp

@@ -25,8 +25,8 @@
 #include "core/hle/service/acc/async_context.h"
 #include "core/hle/service/acc/errors.h"
 #include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/glue/glue_manager.h"
+#include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
@@ -74,12 +74,12 @@ static void SanitizeJPEGImageSize(std::vector<u8>& image) {
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
 public:
-    explicit IManagerForSystemService(Core::System& system_, Common::UUID uuid)
-        : ServiceFramework{system_, "IManagerForSystemService"}, account_id{uuid} {
+    explicit IManagerForSystemService(Core::System& system_, Common::UUID)
+        : ServiceFramework{system_, "IManagerForSystemService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, D<&IManagerForSystemService::CheckAvailability>, "CheckAvailability"},
-            {1, D<&IManagerForSystemService::GetAccountId>, "GetAccountId"},
+            {0, &IManagerForSystemService::CheckAvailability, "CheckAvailability"},
+            {1, nullptr, "GetAccountId"},
             {2, nullptr, "EnsureIdTokenCacheAsync"},
             {3, nullptr, "LoadIdTokenCache"},
             {100, nullptr, "SetSystemProgramIdentification"},
@@ -109,18 +109,11 @@ public:
     }
 
 private:
-    Result CheckAvailability() {
+    void CheckAvailability(HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
-
-    Result GetAccountId(Out<u64> out_account_id) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        *out_account_id = account_id.Hash();
-        R_SUCCEED();
-    }
-
-    Common::UUID account_id;
 };
 
 // 3.0.0+

src/core/hle/service/acc/acc_u1.cpp

@@ -23,7 +23,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
-        {102, &ACC_U1::GetBaasAccountManagerForSystemService, "GetBaasAccountManagerForSystemService"},
+        {102, nullptr, "GetBaasAccountManagerForSystemService"},
         {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
         {104, nullptr, "GetProfileUpdateNotifier"},
         {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},

src/core/hle/service/am/am_types.h

@@ -48,6 +48,11 @@ enum class SystemButtonType {
     CaptureButtonLongPressing,
 };
 
+enum class SysPlatformRegion : s32 {
+    Global = 1,
+    Terra = 2,
+};
+
 struct AppletProcessLaunchReason {
     u8 flag;
     INSERT_PADDING_BYTES(3);

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

@@ -260,9 +260,9 @@ Result ICommonStateGetter::GetAppletLaunchedHistory(
 }
 
 Result ICommonStateGetter::GetSettingsPlatformRegion(
-    Out<Set::PlatformRegion> out_settings_platform_region) {
+    Out<SysPlatformRegion> out_settings_platform_region) {
     LOG_INFO(Service_AM, "called");
-    *out_settings_platform_region = Set::PlatformRegion::Global;
+    *out_settings_platform_region = SysPlatformRegion::Global;
     R_SUCCEED();
 }
 

src/core/hle/service/am/service/common_state_getter.h

@@ -8,7 +8,6 @@
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/set/settings_types.h"
 
 namespace Kernel {
 class KReadableEvent;
@@ -51,7 +50,7 @@ private:
     Result GetOperationModeSystemInfo(Out<u32> out_operation_mode_system_info);
     Result GetAppletLaunchedHistory(Out<s32> out_count,
                                     OutArray<AppletId, BufferAttr_HipcMapAlias> out_applet_ids);
-    Result GetSettingsPlatformRegion(Out<Set::PlatformRegion> out_settings_platform_region);
+    Result GetSettingsPlatformRegion(Out<SysPlatformRegion> out_settings_platform_region);
     Result SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled();
 
     void SetCpuBoostMode(HLERequestContext& ctx);

src/core/hle/service/dmnt/cheat_interface.cpp

@@ -0,0 +1,237 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/dmnt/cheat_interface.h"
+#include "core/hle/service/dmnt/cheat_process_manager.h"
+#include "core/hle/service/dmnt/dmnt_results.h"
+#include "core/hle/service/dmnt/dmnt_types.h"
+
+namespace Service::DMNT {
+
+ICheatInterface::ICheatInterface(Core::System& system_, CheatProcessManager& manager)
+    : ServiceFramework{system_, "dmnt:cht"}, cheat_process_manager{manager} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {65000, C<&ICheatInterface::HasCheatProcess>, "HasCheatProcess"},
+        {65001, C<&ICheatInterface::GetCheatProcessEvent>, "GetCheatProcessEvent"},
+        {65002, C<&ICheatInterface::GetCheatProcessMetadata>, "GetCheatProcessMetadata"},
+        {65003, C<&ICheatInterface::ForceOpenCheatProcess>, "ForceOpenCheatProcess"},
+        {65004, C<&ICheatInterface::PauseCheatProcess>, "PauseCheatProcess"},
+        {65005, C<&ICheatInterface::ResumeCheatProcess>, "ResumeCheatProcess"},
+        {65006, C<&ICheatInterface::ForceCloseCheatProcess>, "ForceCloseCheatProcess"},
+        {65100, C<&ICheatInterface::GetCheatProcessMappingCount>, "GetCheatProcessMappingCount"},
+        {65101, C<&ICheatInterface::GetCheatProcessMappings>, "GetCheatProcessMappings"},
+        {65102, C<&ICheatInterface::ReadCheatProcessMemory>, "ReadCheatProcessMemory"},
+        {65103, C<&ICheatInterface::WriteCheatProcessMemory>, "WriteCheatProcessMemory"},
+        {65104, C<&ICheatInterface::QueryCheatProcessMemory>, "QueryCheatProcessMemory"},
+        {65200, C<&ICheatInterface::GetCheatCount>, "GetCheatCount"},
+        {65201, C<&ICheatInterface::GetCheats>, "GetCheats"},
+        {65202, C<&ICheatInterface::GetCheatById>, "GetCheatById"},
+        {65203, C<&ICheatInterface::ToggleCheat>, "ToggleCheat"},
+        {65204, C<&ICheatInterface::AddCheat>, "AddCheat"},
+        {65205, C<&ICheatInterface::RemoveCheat>, "RemoveCheat"},
+        {65206, C<&ICheatInterface::ReadStaticRegister>, "ReadStaticRegister"},
+        {65207, C<&ICheatInterface::WriteStaticRegister>, "WriteStaticRegister"},
+        {65208, C<&ICheatInterface::ResetStaticRegisters>, "ResetStaticRegisters"},
+        {65209, C<&ICheatInterface::SetMasterCheat>, "SetMasterCheat"},
+        {65300, C<&ICheatInterface::GetFrozenAddressCount>, "GetFrozenAddressCount"},
+        {65301, C<&ICheatInterface::GetFrozenAddresses>, "GetFrozenAddresses"},
+        {65302, C<&ICheatInterface::GetFrozenAddress>, "GetFrozenAddress"},
+        {65303, C<&ICheatInterface::EnableFrozenAddress>, "EnableFrozenAddress"},
+        {65304, C<&ICheatInterface::DisableFrozenAddress>, "DisableFrozenAddress"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+ICheatInterface::~ICheatInterface() = default;
+
+Result ICheatInterface::HasCheatProcess(Out<bool> out_has_cheat) {
+    LOG_INFO(CheatEngine, "called");
+    *out_has_cheat = cheat_process_manager.HasCheatProcess();
+    R_SUCCEED();
+}
+
+Result ICheatInterface::GetCheatProcessEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {
+    LOG_INFO(CheatEngine, "called");
+    *out_event = &cheat_process_manager.GetCheatProcessEvent();
+    R_SUCCEED();
+}
+
+Result ICheatInterface::GetCheatProcessMetadata(Out<CheatProcessMetadata> out_metadata) {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.GetCheatProcessMetadata(*out_metadata));
+}
+
+Result ICheatInterface::ForceOpenCheatProcess() {
+    LOG_INFO(CheatEngine, "called");
+    R_UNLESS(R_SUCCEEDED(cheat_process_manager.ForceOpenCheatProcess()), ResultCheatNotAttached);
+    R_SUCCEED();
+}
+
+Result ICheatInterface::PauseCheatProcess() {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.PauseCheatProcess());
+}
+
+Result ICheatInterface::ResumeCheatProcess() {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.ResumeCheatProcess());
+}
+
+Result ICheatInterface::ForceCloseCheatProcess() {
+    LOG_WARNING(CheatEngine, "(STUBBED) called");
+    R_RETURN(cheat_process_manager.ForceCloseCheatProcess());
+}
+
+Result ICheatInterface::GetCheatProcessMappingCount(Out<u64> out_count) {
+    LOG_WARNING(CheatEngine, "(STUBBED) called");
+    R_RETURN(cheat_process_manager.GetCheatProcessMappingCount(*out_count));
+}
+
+Result ICheatInterface::GetCheatProcessMappings(
+    Out<u64> out_count, u64 offset,
+    OutArray<Kernel::Svc::MemoryInfo, BufferAttr_HipcMapAlias> out_mappings) {
+    LOG_INFO(CheatEngine, "called, offset={}", offset);
+    R_UNLESS(!out_mappings.empty(), ResultCheatNullBuffer);
+    R_RETURN(cheat_process_manager.GetCheatProcessMappings(*out_count, offset, out_mappings));
+}
+
+Result ICheatInterface::ReadCheatProcessMemory(u64 address, u64 size,
+                                               OutBuffer<BufferAttr_HipcMapAlias> out_buffer) {
+    LOG_DEBUG(CheatEngine, "called, address={}, size={}", address, size);
+    R_UNLESS(!out_buffer.empty(), ResultCheatNullBuffer);
+    R_RETURN(cheat_process_manager.ReadCheatProcessMemory(address, size, out_buffer));
+}
+
+Result ICheatInterface::WriteCheatProcessMemory(u64 address, u64 size,
+                                                InBuffer<BufferAttr_HipcMapAlias> buffer) {
+    LOG_DEBUG(CheatEngine, "called, address={}, size={}", address, size);
+    R_UNLESS(!buffer.empty(), ResultCheatNullBuffer);
+    R_RETURN(cheat_process_manager.WriteCheatProcessMemory(address, size, buffer));
+}
+
+Result ICheatInterface::QueryCheatProcessMemory(Out<Kernel::Svc::MemoryInfo> out_mapping,
+                                                u64 address) {
+    LOG_WARNING(CheatEngine, "(STUBBED) called, address={}", address);
+    R_RETURN(cheat_process_manager.QueryCheatProcessMemory(out_mapping, address));
+}
+
+Result ICheatInterface::GetCheatCount(Out<u64> out_count) {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.GetCheatCount(*out_count));
+}
+
+Result ICheatInterface::GetCheats(Out<u64> out_count, u64 offset,
+                                  OutArray<CheatEntry, BufferAttr_HipcMapAlias> out_cheats) {
+    LOG_INFO(CheatEngine, "called, offset={}", offset);
+    R_UNLESS(!out_cheats.empty(), ResultCheatNullBuffer);
+    R_RETURN(cheat_process_manager.GetCheats(*out_count, offset, out_cheats));
+}
+
+Result ICheatInterface::GetCheatById(OutLargeData<CheatEntry, BufferAttr_HipcMapAlias> out_cheat,
+                                     u32 cheat_id) {
+    LOG_INFO(CheatEngine, "called, cheat_id={}", cheat_id);
+    R_RETURN(cheat_process_manager.GetCheatById(out_cheat, cheat_id));
+}
+
+Result ICheatInterface::ToggleCheat(u32 cheat_id) {
+    LOG_INFO(CheatEngine, "called, cheat_id={}", cheat_id);
+    R_RETURN(cheat_process_manager.ToggleCheat(cheat_id));
+}
+
+Result ICheatInterface::AddCheat(
+    Out<u32> out_cheat_id, bool is_enabled,
+    InLargeData<CheatDefinition, BufferAttr_HipcMapAlias> cheat_definition) {
+    LOG_INFO(CheatEngine, "called, is_enabled={}", is_enabled);
+    R_RETURN(cheat_process_manager.AddCheat(*out_cheat_id, is_enabled, *cheat_definition));
+}
+
+Result ICheatInterface::RemoveCheat(u32 cheat_id) {
+    LOG_INFO(CheatEngine, "called, cheat_id={}", cheat_id);
+    R_RETURN(cheat_process_manager.RemoveCheat(cheat_id));
+}
+
+Result ICheatInterface::ReadStaticRegister(Out<u64> out_value, u8 register_index) {
+    LOG_DEBUG(CheatEngine, "called, register_index={}", register_index);
+    R_RETURN(cheat_process_manager.ReadStaticRegister(*out_value, register_index));
+}
+
+Result ICheatInterface::WriteStaticRegister(u8 register_index, u64 value) {
+    LOG_DEBUG(CheatEngine, "called, register_index={, value={}", register_index, value);
+    R_RETURN(cheat_process_manager.WriteStaticRegister(register_index, value));
+}
+
+Result ICheatInterface::ResetStaticRegisters() {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.ResetStaticRegisters());
+}
+
+Result ICheatInterface::SetMasterCheat(
+    InLargeData<CheatDefinition, BufferAttr_HipcMapAlias> cheat_definition) {
+    LOG_INFO(CheatEngine, "called, name={}, num_opcodes={}", cheat_definition->readable_name.data(),
+             cheat_definition->num_opcodes);
+    R_RETURN(cheat_process_manager.SetMasterCheat(*cheat_definition));
+}
+
+Result ICheatInterface::GetFrozenAddressCount(Out<u64> out_count) {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.GetFrozenAddressCount(*out_count));
+}
+
+Result ICheatInterface::GetFrozenAddresses(
+    Out<u64> out_count, u64 offset,
+    OutArray<FrozenAddressEntry, BufferAttr_HipcMapAlias> out_frozen_address) {
+    LOG_INFO(CheatEngine, "called, offset={}", offset);
+    R_UNLESS(!out_frozen_address.empty(), ResultCheatNullBuffer);
+    R_RETURN(cheat_process_manager.GetFrozenAddresses(*out_count, offset, out_frozen_address));
+}
+
+Result ICheatInterface::GetFrozenAddress(Out<FrozenAddressEntry> out_frozen_address_entry,
+                                         u64 address) {
+    LOG_INFO(CheatEngine, "called, address={}", address);
+    R_RETURN(cheat_process_manager.GetFrozenAddress(*out_frozen_address_entry, address));
+}
+
+Result ICheatInterface::EnableFrozenAddress(Out<u64> out_value, u64 address, u64 width) {
+    LOG_INFO(CheatEngine, "called, address={}, width={}", address, width);
+    R_UNLESS(width > 0, ResultFrozenAddressInvalidWidth);
+    R_UNLESS(width <= sizeof(u64), ResultFrozenAddressInvalidWidth);
+    R_UNLESS((width & (width - 1)) == 0, ResultFrozenAddressInvalidWidth);
+    R_RETURN(cheat_process_manager.EnableFrozenAddress(*out_value, address, width));
+}
+
+Result ICheatInterface::DisableFrozenAddress(u64 address) {
+    LOG_INFO(CheatEngine, "called, address={}", address);
+    R_RETURN(cheat_process_manager.DisableFrozenAddress(address));
+}
+
+void ICheatInterface::InitializeCheatManager() {
+    LOG_INFO(CheatEngine, "called");
+}
+
+Result ICheatInterface::ReadCheatProcessMemoryUnsafe(u64 process_addr, std::span<u8> out_data,
+                                                     size_t size) {
+    LOG_DEBUG(CheatEngine, "called, process_addr={}, size={}", process_addr, size);
+    R_RETURN(cheat_process_manager.ReadCheatProcessMemoryUnsafe(process_addr, &out_data, size));
+}
+
+Result ICheatInterface::WriteCheatProcessMemoryUnsafe(u64 process_addr, std::span<const u8> data,
+                                                      size_t size) {
+    LOG_DEBUG(CheatEngine, "called, process_addr={}, size={}", process_addr, size);
+    R_RETURN(cheat_process_manager.WriteCheatProcessMemoryUnsafe(process_addr, &data, size));
+}
+
+Result ICheatInterface::PauseCheatProcessUnsafe() {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.PauseCheatProcessUnsafe());
+}
+
+Result ICheatInterface::ResumeCheatProcessUnsafe() {
+    LOG_INFO(CheatEngine, "called");
+    R_RETURN(cheat_process_manager.ResumeCheatProcessUnsafe());
+}
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/cheat_interface.h

@@ -0,0 +1,86 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KEvent;
+class KReadableEvent;
+} // namespace Kernel
+
+namespace Kernel::Svc {
+struct MemoryInfo;
+}
+
+namespace Service::DMNT {
+struct CheatDefinition;
+struct CheatEntry;
+struct CheatProcessMetadata;
+struct FrozenAddressEntry;
+class CheatProcessManager;
+
+class ICheatInterface final : public ServiceFramework<ICheatInterface> {
+public:
+    explicit ICheatInterface(Core::System& system_, CheatProcessManager& manager);
+    ~ICheatInterface() override;
+
+private:
+    Result HasCheatProcess(Out<bool> out_has_cheat);
+    Result GetCheatProcessEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
+    Result GetCheatProcessMetadata(Out<CheatProcessMetadata> out_metadata);
+    Result ForceOpenCheatProcess();
+    Result PauseCheatProcess();
+    Result ResumeCheatProcess();
+    Result ForceCloseCheatProcess();
+
+    Result GetCheatProcessMappingCount(Out<u64> out_count);
+    Result GetCheatProcessMappings(
+        Out<u64> out_count, u64 offset,
+        OutArray<Kernel::Svc::MemoryInfo, BufferAttr_HipcMapAlias> out_mappings);
+    Result ReadCheatProcessMemory(u64 address, u64 size,
+                                  OutBuffer<BufferAttr_HipcMapAlias> out_buffer);
+    Result WriteCheatProcessMemory(u64 address, u64 size, InBuffer<BufferAttr_HipcMapAlias> buffer);
+
+    Result QueryCheatProcessMemory(Out<Kernel::Svc::MemoryInfo> out_mapping, u64 address);
+    Result GetCheatCount(Out<u64> out_count);
+    Result GetCheats(Out<u64> out_count, u64 offset,
+                     OutArray<CheatEntry, BufferAttr_HipcMapAlias> out_cheats);
+    Result GetCheatById(OutLargeData<CheatEntry, BufferAttr_HipcMapAlias> out_cheat, u32 cheat_id);
+    Result ToggleCheat(u32 cheat_id);
+
+    Result AddCheat(Out<u32> out_cheat_id, bool enabled,
+                    InLargeData<CheatDefinition, BufferAttr_HipcMapAlias> cheat_definition);
+    Result RemoveCheat(u32 cheat_id);
+    Result ReadStaticRegister(Out<u64> out_value, u8 register_index);
+    Result WriteStaticRegister(u8 register_index, u64 value);
+    Result ResetStaticRegisters();
+    Result SetMasterCheat(InLargeData<CheatDefinition, BufferAttr_HipcMapAlias> cheat_definition);
+    Result GetFrozenAddressCount(Out<u64> out_count);
+    Result GetFrozenAddresses(
+        Out<u64> out_count, u64 offset,
+        OutArray<FrozenAddressEntry, BufferAttr_HipcMapAlias> out_frozen_address);
+    Result GetFrozenAddress(Out<FrozenAddressEntry> out_frozen_address_entry, u64 address);
+    Result EnableFrozenAddress(Out<u64> out_value, u64 address, u64 width);
+    Result DisableFrozenAddress(u64 address);
+
+private:
+    void InitializeCheatManager();
+
+    Result ReadCheatProcessMemoryUnsafe(u64 process_addr, std::span<u8> out_data, size_t size);
+    Result WriteCheatProcessMemoryUnsafe(u64 process_addr, std::span<const u8> data, size_t size);
+
+    Result PauseCheatProcessUnsafe();
+    Result ResumeCheatProcessUnsafe();
+
+    CheatProcessManager& cheat_process_manager;
+};
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/cheat_parser.cpp

@@ -0,0 +1,117 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <algorithm>
+#include <cctype>
+#include <optional>
+
+#include "core/hle/service/dmnt/cheat_parser.h"
+#include "core/hle/service/dmnt/dmnt_types.h"
+
+namespace Service::DMNT {
+
+CheatParser::CheatParser() {}
+
+CheatParser::~CheatParser() = default;
+
+std::vector<CheatEntry> CheatParser::Parse(std::string_view data) const {
+    std::vector<CheatEntry> out(1);
+    std::optional<u64> current_entry;
+
+    for (std::size_t i = 0; i < data.size(); ++i) {
+        if (std::isspace(data[i])) {
+            continue;
+        }
+
+        if (data[i] == '{') {
+            current_entry = 0;
+
+            if (out[*current_entry].definition.num_opcodes > 0) {
+                return {};
+            }
+
+            std::size_t name_size{};
+            const auto name = ExtractName(name_size, data, i + 1, '}');
+            if (name.empty()) {
+                return {};
+            }
+
+            std::memcpy(out[*current_entry].definition.readable_name.data(), name.data(),
+                        std::min<std::size_t>(out[*current_entry].definition.readable_name.size(),
+                                              name.size()));
+            out[*current_entry]
+                .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
+                '\0';
+
+            i += name_size + 1;
+        } else if (data[i] == '[') {
+            current_entry = out.size();
+            out.emplace_back();
+
+            std::size_t name_size{};
+            const auto name = ExtractName(name_size, data, i + 1, ']');
+            if (name.empty()) {
+                return {};
+            }
+
+            std::memcpy(out[*current_entry].definition.readable_name.data(), name.data(),
+                        std::min<std::size_t>(out[*current_entry].definition.readable_name.size(),
+                                              name.size()));
+            out[*current_entry]
+                .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
+                '\0';
+
+            i += name_size + 1;
+        } else if (std::isxdigit(data[i])) {
+            if (!current_entry || out[*current_entry].definition.num_opcodes >=
+                                      out[*current_entry].definition.opcodes.size()) {
+                return {};
+            }
+
+            const auto hex = std::string(data.substr(i, 8));
+            if (!std::all_of(hex.begin(), hex.end(), ::isxdigit)) {
+                return {};
+            }
+
+            const auto value = static_cast<u32>(std::strtoul(hex.c_str(), nullptr, 0x10));
+            out[*current_entry].definition.opcodes[out[*current_entry].definition.num_opcodes++] =
+                value;
+
+            i += 8;
+        } else {
+            return {};
+        }
+    }
+
+    out[0].enabled = out[0].definition.num_opcodes > 0;
+    out[0].cheat_id = 0;
+
+    for (u32 i = 1; i < out.size(); ++i) {
+        out[i].enabled = out[i].definition.num_opcodes > 0;
+        out[i].cheat_id = i;
+    }
+
+    return out;
+}
+
+std::string_view CheatParser::ExtractName(std::size_t& out_name_size, std::string_view data,
+                                          std::size_t start_index, char match) const {
+    auto end_index = start_index;
+    while (data[end_index] != match) {
+        ++end_index;
+        if (end_index > data.size()) {
+            return {};
+        }
+    }
+
+    out_name_size = end_index - start_index;
+
+    // Clamp name if it's too big
+    if (out_name_size > sizeof(CheatDefinition::readable_name)) {
+        end_index = start_index + sizeof(CheatDefinition::readable_name);
+    }
+
+    return data.substr(start_index, end_index - start_index);
+}
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/cheat_parser.h

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <string_view>
+#include <vector>
+
+namespace Service::DMNT {
+struct CheatEntry;
+
+class CheatParser final {
+public:
+    CheatParser();
+    ~CheatParser();
+
+    std::vector<CheatEntry> Parse(std::string_view data) const;
+
+private:
+    std::string_view ExtractName(std::size_t& out_name_size, std::string_view data,
+                                 std::size_t start_index, char match) const;
+};
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/cheat_process_manager.cpp

@@ -0,0 +1,597 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/arm/debug.h"
+#include "core/core_timing.h"
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/dmnt/cheat_process_manager.h"
+#include "core/hle/service/dmnt/cheat_virtual_machine.h"
+#include "core/hle/service/dmnt/dmnt_results.h"
+#include "core/hle/service/hid/hid_server.h"
+#include "core/hle/service/sm/sm.h"
+#include "hid_core/resource_manager.h"
+#include "hid_core/resources/npad/npad.h"
+
+namespace Service::DMNT {
+constexpr auto CHEAT_ENGINE_NS = std::chrono::nanoseconds{1000000000 / 12};
+
+CheatProcessManager::CheatProcessManager(Core::System& system_)
+    : system{system_}, service_context{system_, "dmnt:cht"}, core_timing{system_.CoreTiming()} {
+    update_event = Core::Timing::CreateEvent("CheatEngine::FrameCallback",
+                                             [this](s64 time, std::chrono::nanoseconds ns_late)
+                                                 -> std::optional<std::chrono::nanoseconds> {
+                                                 FrameCallback(ns_late);
+                                                 return std::nullopt;
+                                             });
+
+    for (size_t i = 0; i < MaxCheatCount; i++) {
+        ResetCheatEntry(i);
+    }
+
+    cheat_process_event = service_context.CreateEvent("CheatProcessManager::ProcessEvent");
+    unsafe_break_event = service_context.CreateEvent("CheatProcessManager::ProcessEvent");
+}
+
+CheatProcessManager::~CheatProcessManager() {
+    service_context.CloseEvent(cheat_process_event);
+    service_context.CloseEvent(unsafe_break_event);
+    core_timing.UnscheduleEvent(update_event);
+}
+
+void CheatProcessManager::SetVirtualMachine(std::unique_ptr<CheatVirtualMachine> vm) {
+    cheat_vm = std::move(vm);
+    SetNeedsReloadVm(true);
+}
+
+bool CheatProcessManager::HasActiveCheatProcess() {
+    // Note: This function *MUST* be called only with the cheat lock held.
+    bool has_cheat_process =
+        cheat_process_debug_handle != InvalidHandle &&
+        system.ApplicationProcess()->GetProcessId() == cheat_process_metadata.process_id;
+
+    if (!has_cheat_process) {
+        CloseActiveCheatProcess();
+    }
+
+    return has_cheat_process;
+}
+
+void CheatProcessManager::CloseActiveCheatProcess() {
+    if (cheat_process_debug_handle != InvalidHandle) {
+        // We don't need to do any unsafe breaking.
+        broken_unsafe = false;
+        unsafe_break_event->Signal();
+        core_timing.UnscheduleEvent(update_event);
+
+        // Close resources.
+        cheat_process_debug_handle = InvalidHandle;
+
+        // Save cheat toggles.
+        if (always_save_cheat_toggles || should_save_cheat_toggles) {
+            // TODO: save cheat toggles
+            should_save_cheat_toggles = false;
+        }
+
+        // Clear metadata.
+        cheat_process_metadata = {};
+
+        // Clear cheat list.
+        ResetAllCheatEntries();
+
+        // Clear frozen addresses.
+        {
+            auto it = frozen_addresses_map.begin();
+            while (it != frozen_addresses_map.end()) {
+                it = frozen_addresses_map.erase(it);
+            }
+        }
+
+        // Signal to our fans.
+        cheat_process_event->Signal();
+    }
+}
+
+Result CheatProcessManager::EnsureCheatProcess() {
+    R_UNLESS(HasActiveCheatProcess(), ResultCheatNotAttached);
+    R_SUCCEED();
+}
+
+void CheatProcessManager::SetNeedsReloadVm(bool reload) {
+    needs_reload_vm = reload;
+}
+
+void CheatProcessManager::ResetCheatEntry(size_t i) {
+    if (i < MaxCheatCount) {
+        cheat_entries[i] = {};
+        cheat_entries[i].cheat_id = static_cast<u32>(i);
+
+        SetNeedsReloadVm(true);
+    }
+}
+
+void CheatProcessManager::ResetAllCheatEntries() {
+    for (size_t i = 0; i < MaxCheatCount; i++) {
+        ResetCheatEntry(i);
+    }
+
+    cheat_vm->ResetStaticRegisters();
+}
+
+CheatEntry* CheatProcessManager::GetCheatEntryById(size_t i) {
+    if (i < MaxCheatCount) {
+        return cheat_entries.data() + i;
+    }
+
+    return nullptr;
+}
+
+CheatEntry* CheatProcessManager::GetCheatEntryByReadableName(const char* readable_name) {
+    // Check all non-master cheats for match.
+    for (size_t i = 1; i < MaxCheatCount; i++) {
+        if (std::strncmp(cheat_entries[i].definition.readable_name.data(), readable_name,
+                         sizeof(cheat_entries[i].definition.readable_name)) == 0) {
+            return cheat_entries.data() + i;
+        }
+    }
+
+    return nullptr;
+}
+
+CheatEntry* CheatProcessManager::GetFreeCheatEntry() {
+    // Check all non-master cheats for availability.
+    for (size_t i = 1; i < MaxCheatCount; i++) {
+        if (cheat_entries[i].definition.num_opcodes == 0) {
+            return cheat_entries.data() + i;
+        }
+    }
+
+    return nullptr;
+}
+
+bool CheatProcessManager::HasCheatProcess() {
+    std::scoped_lock lk(cheat_lock);
+    return HasActiveCheatProcess();
+}
+
+Kernel::KReadableEvent& CheatProcessManager::GetCheatProcessEvent() const {
+    return cheat_process_event->GetReadableEvent();
+}
+
+Result CheatProcessManager::AttachToApplicationProcess(const std::array<u8, 0x20>& build_id,
+                                                       VAddr main_region_begin,
+                                                       u64 main_region_size) {
+    std::scoped_lock lk(cheat_lock);
+
+    // Close the active process, if needed.
+    {
+        if (this->HasActiveCheatProcess()) {
+            // When forcing attach, we're done.
+            this->CloseActiveCheatProcess();
+        }
+    }
+
+    // Get the application process's ID.
+    cheat_process_metadata.process_id = system.ApplicationProcess()->GetProcessId();
+
+    // Get process handle, use it to learn memory extents.
+    {
+        const auto& page_table = system.ApplicationProcess()->GetPageTable();
+        cheat_process_metadata.program_id = system.GetApplicationProcessProgramID();
+        cheat_process_metadata.heap_extents = {
+            .base = GetInteger(page_table.GetHeapRegionStart()),
+            .size = page_table.GetHeapRegionSize(),
+        };
+        cheat_process_metadata.aslr_extents = {
+            .base = GetInteger(page_table.GetAliasCodeRegionStart()),
+            .size = page_table.GetAliasCodeRegionSize(),
+        };
+        cheat_process_metadata.alias_extents = {
+            .base = GetInteger(page_table.GetAliasRegionStart()),
+            .size = page_table.GetAliasRegionSize(),
+        };
+    }
+
+    // Get module information from loader.
+    {
+        cheat_process_metadata.main_nso_extents = {
+            .base = main_region_begin,
+            .size = main_region_size,
+        };
+        cheat_process_metadata.main_nso_build_id = build_id;
+    }
+
+    // Set our debug handle.
+    cheat_process_debug_handle = cheat_process_metadata.process_id;
+
+    // Reset broken state.
+    broken_unsafe = false;
+    unsafe_break_event->Signal();
+
+    // start the process.
+    core_timing.ScheduleLoopingEvent(CHEAT_ENGINE_NS, CHEAT_ENGINE_NS, update_event);
+
+    // Signal to our fans.
+    cheat_process_event->Signal();
+
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetCheatProcessMetadata(CheatProcessMetadata& out_metadata) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    out_metadata = cheat_process_metadata;
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::ForceOpenCheatProcess() {
+    // R_RETURN(AttachToApplicationProcess(false));
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::PauseCheatProcess() {
+    std::scoped_lock lk(cheat_lock);
+
+    R_TRY(EnsureCheatProcess());
+    R_RETURN(PauseCheatProcessUnsafe());
+}
+
+Result CheatProcessManager::PauseCheatProcessUnsafe() {
+    broken_unsafe = true;
+    unsafe_break_event->Clear();
+    if (system.ApplicationProcess()->IsSuspended()) {
+        R_SUCCEED();
+    }
+    R_RETURN(system.ApplicationProcess()->SetActivity(Kernel::Svc::ProcessActivity::Paused));
+}
+
+Result CheatProcessManager::ResumeCheatProcess() {
+    std::scoped_lock lk(cheat_lock);
+
+    R_TRY(EnsureCheatProcess());
+    R_RETURN(ResumeCheatProcessUnsafe());
+}
+
+Result CheatProcessManager::ResumeCheatProcessUnsafe() {
+    broken_unsafe = true;
+    unsafe_break_event->Clear();
+    if (!system.ApplicationProcess()->IsSuspended()) {
+        R_SUCCEED();
+    }
+    system.ApplicationProcess()->SetActivity(Kernel::Svc::ProcessActivity::Runnable);
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::ForceCloseCheatProcess() {
+    CloseActiveCheatProcess();
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetCheatProcessMappingCount(u64& out_count) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(this->EnsureCheatProcess());
+
+    // TODO: Call svc::QueryDebugProcessMemory
+
+    out_count = 0;
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetCheatProcessMappings(
+    u64& out_count, u64 offset, std::span<Kernel::Svc::MemoryInfo> out_mappings) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(this->EnsureCheatProcess());
+
+    // TODO: Call svc::QueryDebugProcessMemory
+
+    out_count = 0;
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::ReadCheatProcessMemory(u64 process_address, u64 size,
+                                                   std::span<u8> out_data) {
+    std::scoped_lock lk(cheat_lock);
+
+    R_TRY(EnsureCheatProcess());
+    R_RETURN(ReadCheatProcessMemoryUnsafe(process_address, &out_data, size));
+}
+
+Result CheatProcessManager::ReadCheatProcessMemoryUnsafe(u64 process_address, void* out_data,
+                                                         size_t size) {
+    // Return zero on invalid address
+    if (!system.ApplicationMemory().IsValidVirtualAddress(process_address)) {
+        std::memset(out_data, 0, size);
+        R_SUCCEED();
+    }
+
+    system.ApplicationMemory().ReadBlock(process_address, out_data, size);
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::WriteCheatProcessMemory(u64 process_address, u64 size,
+                                                    std::span<const u8> data) {
+    std::scoped_lock lk(cheat_lock);
+
+    R_TRY(EnsureCheatProcess());
+    R_RETURN(WriteCheatProcessMemoryUnsafe(process_address, &data, size));
+}
+
+Result CheatProcessManager::WriteCheatProcessMemoryUnsafe(u64 process_address, const void* data,
+                                                          size_t size) {
+    // Skip invalid memory write address
+    if (!system.ApplicationMemory().IsValidVirtualAddress(process_address)) {
+        R_SUCCEED();
+    }
+
+    if (system.ApplicationMemory().WriteBlock(process_address, data, size)) {
+        Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), process_address, size);
+    }
+
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::QueryCheatProcessMemory(Out<Kernel::Svc::MemoryInfo> mapping,
+                                                    u64 address) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(this->EnsureCheatProcess());
+
+    // TODO: Call svc::QueryDebugProcessMemory
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetCheatCount(u64& out_count) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    out_count = std::count_if(cheat_entries.begin(), cheat_entries.end(),
+                              [](const auto& entry) { return entry.definition.num_opcodes != 0; });
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetCheats(u64& out_count, u64 offset,
+                                      std::span<CheatEntry> out_cheats) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    size_t count = 0, total_count = 0;
+    for (size_t i = 0; i < MaxCheatCount && count < out_cheats.size(); i++) {
+        if (cheat_entries[i].definition.num_opcodes) {
+            total_count++;
+            if (total_count > offset) {
+                out_cheats[count++] = cheat_entries[i];
+            }
+        }
+    }
+
+    out_count = count;
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetCheatById(CheatEntry* out_cheat, u32 cheat_id) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    const CheatEntry* entry = GetCheatEntryById(cheat_id);
+    R_UNLESS(entry != nullptr, ResultCheatUnknownId);
+    R_UNLESS(entry->definition.num_opcodes != 0, ResultCheatUnknownId);
+
+    *out_cheat = *entry;
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::ToggleCheat(u32 cheat_id) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    CheatEntry* entry = GetCheatEntryById(cheat_id);
+    R_UNLESS(entry != nullptr, ResultCheatUnknownId);
+    R_UNLESS(entry->definition.num_opcodes != 0, ResultCheatUnknownId);
+
+    R_UNLESS(cheat_id != 0, ResultCheatCannotDisable);
+
+    entry->enabled = !entry->enabled;
+
+    // Trigger a VM reload.
+    SetNeedsReloadVm(true);
+
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::AddCheat(u32& out_cheat_id, bool enabled,
+                                     const CheatDefinition& cheat_definition) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    R_UNLESS(cheat_definition.num_opcodes != 0, ResultCheatInvalid);
+    R_UNLESS(cheat_definition.num_opcodes <= cheat_definition.opcodes.size(), ResultCheatInvalid);
+
+    CheatEntry* new_entry = GetFreeCheatEntry();
+    R_UNLESS(new_entry != nullptr, ResultCheatOutOfResource);
+
+    new_entry->enabled = enabled;
+    new_entry->definition = cheat_definition;
+
+    // Trigger a VM reload.
+    SetNeedsReloadVm(true);
+
+    // Set output id.
+    out_cheat_id = new_entry->cheat_id;
+
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::RemoveCheat(u32 cheat_id) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+    R_UNLESS(cheat_id < MaxCheatCount, ResultCheatUnknownId);
+
+    ResetCheatEntry(cheat_id);
+    SetNeedsReloadVm(true);
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::ReadStaticRegister(u64& out_value, u64 register_index) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+    R_UNLESS(register_index < CheatVirtualMachine::NumStaticRegisters, ResultCheatInvalid);
+
+    out_value = cheat_vm->GetStaticRegister(register_index);
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::WriteStaticRegister(u64 register_index, u64 value) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+    R_UNLESS(register_index < CheatVirtualMachine::NumStaticRegisters, ResultCheatInvalid);
+
+    cheat_vm->SetStaticRegister(register_index, value);
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::ResetStaticRegisters() {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    cheat_vm->ResetStaticRegisters();
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::SetMasterCheat(const CheatDefinition& cheat_definition) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    R_UNLESS(cheat_definition.num_opcodes != 0, ResultCheatInvalid);
+    R_UNLESS(cheat_definition.num_opcodes <= cheat_definition.opcodes.size(), ResultCheatInvalid);
+
+    cheat_entries[0] = {
+        .enabled = true,
+        .definition = cheat_definition,
+    };
+
+    // Trigger a VM reload.
+    SetNeedsReloadVm(true);
+
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetFrozenAddressCount(u64& out_count) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    out_count = std::distance(frozen_addresses_map.begin(), frozen_addresses_map.end());
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetFrozenAddresses(u64& out_count, u64 offset,
+                                               std::span<FrozenAddressEntry> out_frozen_address) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    u64 total_count = 0, written_count = 0;
+    for (const auto& [address, value] : frozen_addresses_map) {
+        if (written_count >= out_frozen_address.size()) {
+            break;
+        }
+
+        if (offset <= total_count) {
+            out_frozen_address[written_count].address = address;
+            out_frozen_address[written_count].value = value;
+            written_count++;
+        }
+        total_count++;
+    }
+
+    out_count = written_count;
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::GetFrozenAddress(FrozenAddressEntry& out_frozen_address_entry,
+                                             u64 address) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    const auto it = frozen_addresses_map.find(address);
+    R_UNLESS(it != frozen_addresses_map.end(), ResultFrozenAddressNotFound);
+
+    out_frozen_address_entry = {
+        .address = it->first,
+        .value = it->second,
+    };
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::EnableFrozenAddress(u64& out_value, u64 address, u64 width) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    const auto it = frozen_addresses_map.find(address);
+    R_UNLESS(it == frozen_addresses_map.end(), ResultFrozenAddressAlreadyExists);
+
+    FrozenAddressValue value{};
+    value.width = static_cast<u8>(width);
+    R_TRY(ReadCheatProcessMemoryUnsafe(address, &value.value, width));
+
+    frozen_addresses_map.insert({address, value});
+    out_value = value.value;
+    R_SUCCEED();
+}
+
+Result CheatProcessManager::DisableFrozenAddress(u64 address) {
+    std::scoped_lock lk(cheat_lock);
+    R_TRY(EnsureCheatProcess());
+
+    const auto it = frozen_addresses_map.find(address);
+    R_UNLESS(it != frozen_addresses_map.end(), ResultFrozenAddressNotFound);
+
+    frozen_addresses_map.erase(it);
+
+    R_SUCCEED();
+}
+
+u64 CheatProcessManager::HidKeysDown() const {
+    const auto hid = system.ServiceManager().GetService<Service::HID::IHidServer>("hid");
+    if (hid == nullptr) {
+        LOG_WARNING(CheatEngine, "Attempted to read input state, but hid is not initialized!");
+        return 0;
+    }
+
+    const auto applet_resource = hid->GetResourceManager();
+    if (applet_resource == nullptr || applet_resource->GetNpad() == nullptr) {
+        LOG_WARNING(CheatEngine,
+                    "Attempted to read input state, but applet resource is not initialized!");
+        return 0;
+    }
+
+    const auto press_state = applet_resource->GetNpad()->GetAndResetPressState();
+    return static_cast<u64>(press_state & Core::HID::NpadButton::All);
+}
+
+void CheatProcessManager::DebugLog(u8 id, u64 value) const {
+    LOG_INFO(CheatEngine, "Cheat triggered DebugLog: ID '{:01X}' Value '{:016X}'", id, value);
+}
+
+void CheatProcessManager::CommandLog(std::string_view data) const {
+    LOG_DEBUG(CheatEngine, "[DmntCheatVm]: {}",
+              data.back() == '\n' ? data.substr(0, data.size() - 1) : data);
+}
+
+void CheatProcessManager::FrameCallback(std::chrono::nanoseconds ns_late) {
+    std::scoped_lock lk(cheat_lock);
+
+    if (cheat_vm == nullptr) {
+        return;
+    }
+
+    if (needs_reload_vm) {
+        cheat_vm->LoadProgram(cheat_entries);
+        needs_reload_vm = false;
+    }
+
+    if (cheat_vm->GetProgramSize() == 0) {
+        return;
+    }
+
+    cheat_vm->Execute(cheat_process_metadata);
+}
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/cheat_process_manager.h

@@ -0,0 +1,124 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <map>
+#include <span>
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/dmnt/dmnt_types.h"
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/service.h"
+
+#include "common/intrusive_red_black_tree.h"
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KEvent;
+class KReadableEvent;
+} // namespace Kernel
+
+namespace Kernel::Svc {
+struct MemoryInfo;
+}
+
+namespace Service::DMNT {
+class CheatVirtualMachine;
+
+class CheatProcessManager final {
+public:
+    static constexpr size_t MaxCheatCount = 0x80;
+    static constexpr size_t MaxFrozenAddressCount = 0x80;
+
+    CheatProcessManager(Core::System& system_);
+    ~CheatProcessManager();
+
+    void SetVirtualMachine(std::unique_ptr<CheatVirtualMachine> vm);
+
+    bool HasCheatProcess();
+    Kernel::KReadableEvent& GetCheatProcessEvent() const;
+    Result GetCheatProcessMetadata(CheatProcessMetadata& out_metadata);
+    Result AttachToApplicationProcess(const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
+                                      u64 main_region_size);
+    Result ForceOpenCheatProcess();
+    Result PauseCheatProcess();
+    Result PauseCheatProcessUnsafe();
+    Result ResumeCheatProcess();
+    Result ResumeCheatProcessUnsafe();
+    Result ForceCloseCheatProcess();
+
+    Result GetCheatProcessMappingCount(u64& out_count);
+    Result GetCheatProcessMappings(u64& out_count, u64 offset,
+                                   std::span<Kernel::Svc::MemoryInfo> out_mappings);
+    Result ReadCheatProcessMemory(u64 process_address, u64 size, std::span<u8> out_data);
+    Result ReadCheatProcessMemoryUnsafe(u64 process_address, void* out_data, size_t size);
+    Result WriteCheatProcessMemory(u64 process_address, u64 size, std::span<const u8> data);
+    Result WriteCheatProcessMemoryUnsafe(u64 process_address, const void* data, size_t size);
+
+    Result QueryCheatProcessMemory(Out<Kernel::Svc::MemoryInfo> mapping, u64 address);
+    Result GetCheatCount(u64& out_count);
+    Result GetCheats(u64& out_count, u64 offset, std::span<CheatEntry> out_cheats);
+    Result GetCheatById(CheatEntry* out_cheat, u32 cheat_id);
+    Result ToggleCheat(u32 cheat_id);
+
+    Result AddCheat(u32& out_cheat_id, bool enabled, const CheatDefinition& cheat_definition);
+    Result RemoveCheat(u32 cheat_id);
+    Result ReadStaticRegister(u64& out_value, u64 register_index);
+    Result WriteStaticRegister(u64 register_index, u64 value);
+    Result ResetStaticRegisters();
+    Result SetMasterCheat(const CheatDefinition& cheat_definition);
+    Result GetFrozenAddressCount(u64& out_count);
+    Result GetFrozenAddresses(u64& out_count, u64 offset,
+                              std::span<FrozenAddressEntry> out_frozen_address);
+    Result GetFrozenAddress(FrozenAddressEntry& out_frozen_address_entry, u64 address);
+    Result EnableFrozenAddress(u64& out_value, u64 address, u64 width);
+    Result DisableFrozenAddress(u64 address);
+
+    u64 HidKeysDown() const;
+    void DebugLog(u8 id, u64 value) const;
+    void CommandLog(std::string_view data) const;
+
+private:
+    bool HasActiveCheatProcess();
+    void CloseActiveCheatProcess();
+    Result EnsureCheatProcess();
+    void SetNeedsReloadVm(bool reload);
+    void ResetCheatEntry(size_t i);
+    void ResetAllCheatEntries();
+    CheatEntry* GetCheatEntryById(size_t i);
+    CheatEntry* GetCheatEntryByReadableName(const char* readable_name);
+    CheatEntry* GetFreeCheatEntry();
+
+    void FrameCallback(std::chrono::nanoseconds ns_late);
+
+    static constexpr u64 InvalidHandle = 0;
+
+    mutable std::mutex cheat_lock;
+    Kernel::KEvent* unsafe_break_event;
+
+    Kernel::KEvent* cheat_process_event;
+    u64 cheat_process_debug_handle = InvalidHandle;
+    CheatProcessMetadata cheat_process_metadata = {};
+
+    bool broken_unsafe = false;
+    bool needs_reload_vm = false;
+    std::unique_ptr<CheatVirtualMachine> cheat_vm;
+
+    bool enable_cheats_by_default = true;
+    bool always_save_cheat_toggles = false;
+    bool should_save_cheat_toggles = false;
+    std::array<CheatEntry, MaxCheatCount> cheat_entries = {};
+    // TODO: Replace with IntrusiveRedBlackTree
+    std::map<u64, FrozenAddressValue> frozen_addresses_map = {};
+
+    Core::System& system;
+    KernelHelpers::ServiceContext service_context;
+    std::shared_ptr<Core::Timing::EventType> update_event;
+    Core::Timing::CoreTiming& core_timing;
+};
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/cheat_virtual_machine.cpp

@@ -1,226 +1,221 @@
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <fmt/printf.h>
+
 #include "common/assert.h"
 #include "common/scope_exit.h"
-#include "core/memory/dmnt_cheat_types.h"
-#include "core/memory/dmnt_cheat_vm.h"
+#include "core/hle/service/dmnt/cheat_process_manager.h"
+#include "core/hle/service/dmnt/cheat_virtual_machine.h"
 
-namespace Core::Memory {
+namespace Service::DMNT {
 
-DmntCheatVm::DmntCheatVm(std::unique_ptr<Callbacks> callbacks_)
-    : callbacks(std::move(callbacks_)) {}
+CheatVirtualMachine::CheatVirtualMachine(CheatProcessManager& cheat_manager)
+    : manager(cheat_manager) {}
 
-DmntCheatVm::~DmntCheatVm() = default;
+CheatVirtualMachine::~CheatVirtualMachine() = default;
 
-void DmntCheatVm::DebugLog(u32 log_id, u64 value) {
-    callbacks->DebugLog(static_cast<u8>(log_id), value);
+void CheatVirtualMachine::DebugLog(u32 log_id, u64 value) const {
+    manager.DebugLog(static_cast<u8>(log_id), value);
 }
 
-void DmntCheatVm::LogOpcode(const CheatVmOpcode& opcode) {
+void CheatVirtualMachine::LogOpcode(const CheatVmOpcode& opcode) const {
     if (auto store_static = std::get_if<StoreStaticOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Store Static");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", store_static->bit_width));
-        callbacks->CommandLog(
+        manager.CommandLog("Opcode: Store Static");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", store_static->bit_width));
+        manager.CommandLog(
             fmt::format("Mem Type:  {:X}", static_cast<u32>(store_static->mem_type)));
-        callbacks->CommandLog(fmt::format("Reg Idx:   {:X}", store_static->offset_register));
-        callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", store_static->rel_address));
-        callbacks->CommandLog(fmt::format("Value:     {:X}", store_static->value.bit64));
+        manager.CommandLog(fmt::format("Reg Idx:   {:X}", store_static->offset_register));
+        manager.CommandLog(fmt::format("Rel Addr:  {:X}", store_static->rel_address));
+        manager.CommandLog(fmt::format("Value:     {:X}", store_static->value.bit64));
     } else if (auto begin_cond = std::get_if<BeginConditionalOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Begin Conditional");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", begin_cond->bit_width));
-        callbacks->CommandLog(
-            fmt::format("Mem Type:  {:X}", static_cast<u32>(begin_cond->mem_type)));
-        callbacks->CommandLog(
-            fmt::format("Cond Type: {:X}", static_cast<u32>(begin_cond->cond_type)));
-        callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", begin_cond->rel_address));
-        callbacks->CommandLog(fmt::format("Value:     {:X}", begin_cond->value.bit64));
+        manager.CommandLog("Opcode: Begin Conditional");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", begin_cond->bit_width));
+        manager.CommandLog(fmt::format("Mem Type:  {:X}", static_cast<u32>(begin_cond->mem_type)));
+        manager.CommandLog(fmt::format("Cond Type: {:X}", static_cast<u32>(begin_cond->cond_type)));
+        manager.CommandLog(fmt::format("Rel Addr:  {:X}", begin_cond->rel_address));
+        manager.CommandLog(fmt::format("Value:     {:X}", begin_cond->value.bit64));
     } else if (std::holds_alternative<EndConditionalOpcode>(opcode.opcode)) {
-        callbacks->CommandLog("Opcode: End Conditional");
+        manager.CommandLog("Opcode: End Conditional");
     } else if (auto ctrl_loop = std::get_if<ControlLoopOpcode>(&opcode.opcode)) {
         if (ctrl_loop->start_loop) {
-            callbacks->CommandLog("Opcode: Start Loop");
-            callbacks->CommandLog(fmt::format("Reg Idx:   {:X}", ctrl_loop->reg_index));
-            callbacks->CommandLog(fmt::format("Num Iters: {:X}", ctrl_loop->num_iters));
+            manager.CommandLog("Opcode: Start Loop");
+            manager.CommandLog(fmt::format("Reg Idx:   {:X}", ctrl_loop->reg_index));
+            manager.CommandLog(fmt::format("Num Iters: {:X}", ctrl_loop->num_iters));
         } else {
-            callbacks->CommandLog("Opcode: End Loop");
-            callbacks->CommandLog(fmt::format("Reg Idx:   {:X}", ctrl_loop->reg_index));
+            manager.CommandLog("Opcode: End Loop");
+            manager.CommandLog(fmt::format("Reg Idx:   {:X}", ctrl_loop->reg_index));
         }
     } else if (auto ldr_static = std::get_if<LoadRegisterStaticOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Load Register Static");
-        callbacks->CommandLog(fmt::format("Reg Idx:   {:X}", ldr_static->reg_index));
-        callbacks->CommandLog(fmt::format("Value:     {:X}", ldr_static->value));
+        manager.CommandLog("Opcode: Load Register Static");
+        manager.CommandLog(fmt::format("Reg Idx:   {:X}", ldr_static->reg_index));
+        manager.CommandLog(fmt::format("Value:     {:X}", ldr_static->value));
     } else if (auto ldr_memory = std::get_if<LoadRegisterMemoryOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Load Register Memory");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", ldr_memory->bit_width));
-        callbacks->CommandLog(fmt::format("Reg Idx:   {:X}", ldr_memory->reg_index));
-        callbacks->CommandLog(
-            fmt::format("Mem Type:  {:X}", static_cast<u32>(ldr_memory->mem_type)));
-        callbacks->CommandLog(fmt::format("From Reg:  {:d}", ldr_memory->load_from_reg));
-        callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", ldr_memory->rel_address));
+        manager.CommandLog("Opcode: Load Register Memory");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", ldr_memory->bit_width));
+        manager.CommandLog(fmt::format("Reg Idx:   {:X}", ldr_memory->reg_index));
+        manager.CommandLog(fmt::format("Mem Type:  {:X}", static_cast<u32>(ldr_memory->mem_type)));
+        manager.CommandLog(fmt::format("From Reg:  {:d}", ldr_memory->load_from_reg));
+        manager.CommandLog(fmt::format("Rel Addr:  {:X}", ldr_memory->rel_address));
     } else if (auto str_static = std::get_if<StoreStaticToAddressOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Store Static to Address");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", str_static->bit_width));
-        callbacks->CommandLog(fmt::format("Reg Idx:   {:X}", str_static->reg_index));
+        manager.CommandLog("Opcode: Store Static to Address");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", str_static->bit_width));
+        manager.CommandLog(fmt::format("Reg Idx:   {:X}", str_static->reg_index));
         if (str_static->add_offset_reg) {
-            callbacks->CommandLog(fmt::format("O Reg Idx: {:X}", str_static->offset_reg_index));
+            manager.CommandLog(fmt::format("O Reg Idx: {:X}", str_static->offset_reg_index));
         }
-        callbacks->CommandLog(fmt::format("Incr Reg:  {:d}", str_static->increment_reg));
-        callbacks->CommandLog(fmt::format("Value:     {:X}", str_static->value));
+        manager.CommandLog(fmt::format("Incr Reg:  {:d}", str_static->increment_reg));
+        manager.CommandLog(fmt::format("Value:     {:X}", str_static->value));
     } else if (auto perform_math_static =
                    std::get_if<PerformArithmeticStaticOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Perform Static Arithmetic");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", perform_math_static->bit_width));
-        callbacks->CommandLog(fmt::format("Reg Idx:   {:X}", perform_math_static->reg_index));
-        callbacks->CommandLog(
+        manager.CommandLog("Opcode: Perform Static Arithmetic");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", perform_math_static->bit_width));
+        manager.CommandLog(fmt::format("Reg Idx:   {:X}", perform_math_static->reg_index));
+        manager.CommandLog(
             fmt::format("Math Type: {:X}", static_cast<u32>(perform_math_static->math_type)));
-        callbacks->CommandLog(fmt::format("Value:     {:X}", perform_math_static->value));
+        manager.CommandLog(fmt::format("Value:     {:X}", perform_math_static->value));
     } else if (auto begin_keypress_cond =
                    std::get_if<BeginKeypressConditionalOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Begin Keypress Conditional");
-        callbacks->CommandLog(fmt::format("Key Mask:  {:X}", begin_keypress_cond->key_mask));
+        manager.CommandLog("Opcode: Begin Keypress Conditional");
+        manager.CommandLog(fmt::format("Key Mask:  {:X}", begin_keypress_cond->key_mask));
     } else if (auto perform_math_reg =
                    std::get_if<PerformArithmeticRegisterOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Perform Register Arithmetic");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", perform_math_reg->bit_width));
-        callbacks->CommandLog(fmt::format("Dst Idx:   {:X}", perform_math_reg->dst_reg_index));
-        callbacks->CommandLog(fmt::format("Src1 Idx:  {:X}", perform_math_reg->src_reg_1_index));
+        manager.CommandLog("Opcode: Perform Register Arithmetic");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", perform_math_reg->bit_width));
+        manager.CommandLog(fmt::format("Dst Idx:   {:X}", perform_math_reg->dst_reg_index));
+        manager.CommandLog(fmt::format("Src1 Idx:  {:X}", perform_math_reg->src_reg_1_index));
         if (perform_math_reg->has_immediate) {
-            callbacks->CommandLog(fmt::format("Value:     {:X}", perform_math_reg->value.bit64));
+            manager.CommandLog(fmt::format("Value:     {:X}", perform_math_reg->value.bit64));
         } else {
-            callbacks->CommandLog(
-                fmt::format("Src2 Idx:  {:X}", perform_math_reg->src_reg_2_index));
+            manager.CommandLog(fmt::format("Src2 Idx:  {:X}", perform_math_reg->src_reg_2_index));
         }
     } else if (auto str_register = std::get_if<StoreRegisterToAddressOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Store Register to Address");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", str_register->bit_width));
-        callbacks->CommandLog(fmt::format("S Reg Idx: {:X}", str_register->str_reg_index));
-        callbacks->CommandLog(fmt::format("A Reg Idx: {:X}", str_register->addr_reg_index));
-        callbacks->CommandLog(fmt::format("Incr Reg:  {:d}", str_register->increment_reg));
+        manager.CommandLog("Opcode: Store Register to Address");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", str_register->bit_width));
+        manager.CommandLog(fmt::format("S Reg Idx: {:X}", str_register->str_reg_index));
+        manager.CommandLog(fmt::format("A Reg Idx: {:X}", str_register->addr_reg_index));
+        manager.CommandLog(fmt::format("Incr Reg:  {:d}", str_register->increment_reg));
         switch (str_register->ofs_type) {
         case StoreRegisterOffsetType::None:
             break;
         case StoreRegisterOffsetType::Reg:
-            callbacks->CommandLog(fmt::format("O Reg Idx: {:X}", str_register->ofs_reg_index));
+            manager.CommandLog(fmt::format("O Reg Idx: {:X}", str_register->ofs_reg_index));
             break;
         case StoreRegisterOffsetType::Imm:
-            callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", str_register->rel_address));
+            manager.CommandLog(fmt::format("Rel Addr:  {:X}", str_register->rel_address));
             break;
         case StoreRegisterOffsetType::MemReg:
-            callbacks->CommandLog(
+            manager.CommandLog(
                 fmt::format("Mem Type:  {:X}", static_cast<u32>(str_register->mem_type)));
             break;
         case StoreRegisterOffsetType::MemImm:
         case StoreRegisterOffsetType::MemImmReg:
-            callbacks->CommandLog(
+            manager.CommandLog(
                 fmt::format("Mem Type:  {:X}", static_cast<u32>(str_register->mem_type)));
-            callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", str_register->rel_address));
+            manager.CommandLog(fmt::format("Rel Addr:  {:X}", str_register->rel_address));
             break;
         }
     } else if (auto begin_reg_cond = std::get_if<BeginRegisterConditionalOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Begin Register Conditional");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", begin_reg_cond->bit_width));
-        callbacks->CommandLog(
+        manager.CommandLog("Opcode: Begin Register Conditional");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", begin_reg_cond->bit_width));
+        manager.CommandLog(
             fmt::format("Cond Type: {:X}", static_cast<u32>(begin_reg_cond->cond_type)));
-        callbacks->CommandLog(fmt::format("V Reg Idx: {:X}", begin_reg_cond->val_reg_index));
+        manager.CommandLog(fmt::format("V Reg Idx: {:X}", begin_reg_cond->val_reg_index));
         switch (begin_reg_cond->comp_type) {
         case CompareRegisterValueType::StaticValue:
-            callbacks->CommandLog("Comp Type: Static Value");
-            callbacks->CommandLog(fmt::format("Value:     {:X}", begin_reg_cond->value.bit64));
+            manager.CommandLog("Comp Type: Static Value");
+            manager.CommandLog(fmt::format("Value:     {:X}", begin_reg_cond->value.bit64));
             break;
         case CompareRegisterValueType::OtherRegister:
-            callbacks->CommandLog("Comp Type: Other Register");
-            callbacks->CommandLog(fmt::format("X Reg Idx: {:X}", begin_reg_cond->other_reg_index));
+            manager.CommandLog("Comp Type: Other Register");
+            manager.CommandLog(fmt::format("X Reg Idx: {:X}", begin_reg_cond->other_reg_index));
             break;
         case CompareRegisterValueType::MemoryRelAddr:
-            callbacks->CommandLog("Comp Type: Memory Relative Address");
-            callbacks->CommandLog(
+            manager.CommandLog("Comp Type: Memory Relative Address");
+            manager.CommandLog(
                 fmt::format("Mem Type:  {:X}", static_cast<u32>(begin_reg_cond->mem_type)));
-            callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", begin_reg_cond->rel_address));
+            manager.CommandLog(fmt::format("Rel Addr:  {:X}", begin_reg_cond->rel_address));
             break;
         case CompareRegisterValueType::MemoryOfsReg:
-            callbacks->CommandLog("Comp Type: Memory Offset Register");
-            callbacks->CommandLog(
+            manager.CommandLog("Comp Type: Memory Offset Register");
+            manager.CommandLog(
                 fmt::format("Mem Type:  {:X}", static_cast<u32>(begin_reg_cond->mem_type)));
-            callbacks->CommandLog(fmt::format("O Reg Idx: {:X}", begin_reg_cond->ofs_reg_index));
+            manager.CommandLog(fmt::format("O Reg Idx: {:X}", begin_reg_cond->ofs_reg_index));
             break;
         case CompareRegisterValueType::RegisterRelAddr:
-            callbacks->CommandLog("Comp Type: Register Relative Address");
-            callbacks->CommandLog(fmt::format("A Reg Idx: {:X}", begin_reg_cond->addr_reg_index));
-            callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", begin_reg_cond->rel_address));
+            manager.CommandLog("Comp Type: Register Relative Address");
+            manager.CommandLog(fmt::format("A Reg Idx: {:X}", begin_reg_cond->addr_reg_index));
+            manager.CommandLog(fmt::format("Rel Addr:  {:X}", begin_reg_cond->rel_address));
             break;
         case CompareRegisterValueType::RegisterOfsReg:
-            callbacks->CommandLog("Comp Type: Register Offset Register");
-            callbacks->CommandLog(fmt::format("A Reg Idx: {:X}", begin_reg_cond->addr_reg_index));
-            callbacks->CommandLog(fmt::format("O Reg Idx: {:X}", begin_reg_cond->ofs_reg_index));
+            manager.CommandLog("Comp Type: Register Offset Register");
+            manager.CommandLog(fmt::format("A Reg Idx: {:X}", begin_reg_cond->addr_reg_index));
+            manager.CommandLog(fmt::format("O Reg Idx: {:X}", begin_reg_cond->ofs_reg_index));
             break;
         }
     } else if (auto save_restore_reg = std::get_if<SaveRestoreRegisterOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Save or Restore Register");
-        callbacks->CommandLog(fmt::format("Dst Idx:   {:X}", save_restore_reg->dst_index));
-        callbacks->CommandLog(fmt::format("Src Idx:   {:X}", save_restore_reg->src_index));
-        callbacks->CommandLog(
+        manager.CommandLog("Opcode: Save or Restore Register");
+        manager.CommandLog(fmt::format("Dst Idx:   {:X}", save_restore_reg->dst_index));
+        manager.CommandLog(fmt::format("Src Idx:   {:X}", save_restore_reg->src_index));
+        manager.CommandLog(
             fmt::format("Op Type:   {:d}", static_cast<u32>(save_restore_reg->op_type)));
     } else if (auto save_restore_regmask =
                    std::get_if<SaveRestoreRegisterMaskOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Save or Restore Register Mask");
-        callbacks->CommandLog(
+        manager.CommandLog("Opcode: Save or Restore Register Mask");
+        manager.CommandLog(
             fmt::format("Op Type:   {:d}", static_cast<u32>(save_restore_regmask->op_type)));
         for (std::size_t i = 0; i < NumRegisters; i++) {
-            callbacks->CommandLog(
+            manager.CommandLog(
                 fmt::format("Act[{:02X}]:   {:d}", i, save_restore_regmask->should_operate[i]));
         }
     } else if (auto rw_static_reg = std::get_if<ReadWriteStaticRegisterOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Read/Write Static Register");
+        manager.CommandLog("Opcode: Read/Write Static Register");
         if (rw_static_reg->static_idx < NumReadableStaticRegisters) {
-            callbacks->CommandLog("Op Type: ReadStaticRegister");
+            manager.CommandLog("Op Type: ReadStaticRegister");
         } else {
-            callbacks->CommandLog("Op Type: WriteStaticRegister");
+            manager.CommandLog("Op Type: WriteStaticRegister");
         }
-        callbacks->CommandLog(fmt::format("Reg Idx   {:X}", rw_static_reg->idx));
-        callbacks->CommandLog(fmt::format("Stc Idx   {:X}", rw_static_reg->static_idx));
+        manager.CommandLog(fmt::format("Reg Idx   {:X}", rw_static_reg->idx));
+        manager.CommandLog(fmt::format("Stc Idx   {:X}", rw_static_reg->static_idx));
     } else if (auto debug_log = std::get_if<DebugLogOpcode>(&opcode.opcode)) {
-        callbacks->CommandLog("Opcode: Debug Log");
-        callbacks->CommandLog(fmt::format("Bit Width: {:X}", debug_log->bit_width));
-        callbacks->CommandLog(fmt::format("Log ID:    {:X}", debug_log->log_id));
-        callbacks->CommandLog(
-            fmt::format("Val Type:  {:X}", static_cast<u32>(debug_log->val_type)));
+        manager.CommandLog("Opcode: Debug Log");
+        manager.CommandLog(fmt::format("Bit Width: {:X}", debug_log->bit_width));
+        manager.CommandLog(fmt::format("Log ID:    {:X}", debug_log->log_id));
+        manager.CommandLog(fmt::format("Val Type:  {:X}", static_cast<u32>(debug_log->val_type)));
         switch (debug_log->val_type) {
         case DebugLogValueType::RegisterValue:
-            callbacks->CommandLog("Val Type:  Register Value");
-            callbacks->CommandLog(fmt::format("X Reg Idx: {:X}", debug_log->val_reg_index));
+            manager.CommandLog("Val Type:  Register Value");
+            manager.CommandLog(fmt::format("X Reg Idx: {:X}", debug_log->val_reg_index));
             break;
         case DebugLogValueType::MemoryRelAddr:
-            callbacks->CommandLog("Val Type:  Memory Relative Address");
-            callbacks->CommandLog(
+            manager.CommandLog("Val Type:  Memory Relative Address");
+            manager.CommandLog(
                 fmt::format("Mem Type:  {:X}", static_cast<u32>(debug_log->mem_type)));
-            callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", debug_log->rel_address));
+            manager.CommandLog(fmt::format("Rel Addr:  {:X}", debug_log->rel_address));
             break;
         case DebugLogValueType::MemoryOfsReg:
-            callbacks->CommandLog("Val Type:  Memory Offset Register");
-            callbacks->CommandLog(
+            manager.CommandLog("Val Type:  Memory Offset Register");
+            manager.CommandLog(
                 fmt::format("Mem Type:  {:X}", static_cast<u32>(debug_log->mem_type)));
-            callbacks->CommandLog(fmt::format("O Reg Idx: {:X}", debug_log->ofs_reg_index));
+            manager.CommandLog(fmt::format("O Reg Idx: {:X}", debug_log->ofs_reg_index));
             break;
         case DebugLogValueType::RegisterRelAddr:
-            callbacks->CommandLog("Val Type:  Register Relative Address");
-            callbacks->CommandLog(fmt::format("A Reg Idx: {:X}", debug_log->addr_reg_index));
-            callbacks->CommandLog(fmt::format("Rel Addr:  {:X}", debug_log->rel_address));
+            manager.CommandLog("Val Type:  Register Relative Address");
+            manager.CommandLog(fmt::format("A Reg Idx: {:X}", debug_log->addr_reg_index));
+            manager.CommandLog(fmt::format("Rel Addr:  {:X}", debug_log->rel_address));
             break;
         case DebugLogValueType::RegisterOfsReg:
-            callbacks->CommandLog("Val Type:  Register Offset Register");
-            callbacks->CommandLog(fmt::format("A Reg Idx: {:X}", debug_log->addr_reg_index));
-            callbacks->CommandLog(fmt::format("O Reg Idx: {:X}", debug_log->ofs_reg_index));
+            manager.CommandLog("Val Type:  Register Offset Register");
+            manager.CommandLog(fmt::format("A Reg Idx: {:X}", debug_log->addr_reg_index));
+            manager.CommandLog(fmt::format("O Reg Idx: {:X}", debug_log->ofs_reg_index));
             break;
         }
     } else if (auto instr = std::get_if<UnrecognizedInstruction>(&opcode.opcode)) {
-        callbacks->CommandLog(fmt::format("Unknown opcode: {:X}", static_cast<u32>(instr->opcode)));
+        manager.CommandLog(fmt::format("Unknown opcode: {:X}", static_cast<u32>(instr->opcode)));
     }
 }
 
-DmntCheatVm::Callbacks::~Callbacks() = default;
-
-bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
+bool CheatVirtualMachine::DecodeNextOpcode(CheatVmOpcode& out) {
     // If we've ever seen a decode failure, return false.
     bool valid = decode_success;
     CheatVmOpcode opcode = {};
@@ -634,7 +629,7 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
     return valid;
 }
 
-void DmntCheatVm::SkipConditionalBlock(bool is_if) {
+void CheatVirtualMachine::SkipConditionalBlock(bool is_if) {
     if (condition_depth > 0) {
         // We want to continue until we're out of the current block.
         const std::size_t desired_depth = condition_depth - 1;
@@ -668,7 +663,7 @@ void DmntCheatVm::SkipConditionalBlock(bool is_if) {
     }
 }
 
-u64 DmntCheatVm::GetVmInt(VmInt value, u32 bit_width) {
+u64 CheatVirtualMachine::GetVmInt(VmInt value, u32 bit_width) {
     switch (bit_width) {
     case 1:
         return value.bit8;
@@ -684,8 +679,8 @@ u64 DmntCheatVm::GetVmInt(VmInt value, u32 bit_width) {
     }
 }
 
-u64 DmntCheatVm::GetCheatProcessAddress(const CheatProcessMetadata& metadata,
-                                        MemoryAccessType mem_type, u64 rel_address) {
+u64 CheatVirtualMachine::GetCheatProcessAddress(const CheatProcessMetadata& metadata,
+                                                MemoryAccessType mem_type, u64 rel_address) {
     switch (mem_type) {
     case MemoryAccessType::MainNso:
     default:
@@ -699,7 +694,7 @@ u64 DmntCheatVm::GetCheatProcessAddress(const CheatProcessMetadata& metadata,
     }
 }
 
-void DmntCheatVm::ResetState() {
+void CheatVirtualMachine::ResetState() {
     registers.fill(0);
     saved_values.fill(0);
     loop_tops.fill(0);
@@ -708,7 +703,7 @@ void DmntCheatVm::ResetState() {
     decode_success = true;
 }
 
-bool DmntCheatVm::LoadProgram(const std::vector<CheatEntry>& entries) {
+bool CheatVirtualMachine::LoadProgram(std::span<const CheatEntry> entries) {
     // Reset opcode count.
     num_opcodes = 0;
 
@@ -729,31 +724,31 @@ bool DmntCheatVm::LoadProgram(const std::vector<CheatEntry>& entries) {
     return true;
 }
 
-void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
+void CheatVirtualMachine::Execute(const CheatProcessMetadata& metadata) {
     CheatVmOpcode cur_opcode{};
 
     // Get Keys down.
-    u64 kDown = callbacks->HidKeysDown();
+    u64 kDown = manager.HidKeysDown();
 
-    callbacks->CommandLog("Started VM execution.");
-    callbacks->CommandLog(fmt::format("Main NSO:  {:012X}", metadata.main_nso_extents.base));
-    callbacks->CommandLog(fmt::format("Heap:      {:012X}", metadata.main_nso_extents.base));
-    callbacks->CommandLog(fmt::format("Keys Down: {:08X}", static_cast<u32>(kDown & 0x0FFFFFFF)));
+    manager.CommandLog("Started VM execution.");
+    manager.CommandLog(fmt::format("Main NSO:  {:012X}", metadata.main_nso_extents.base));
+    manager.CommandLog(fmt::format("Heap:      {:012X}", metadata.main_nso_extents.base));
+    manager.CommandLog(fmt::format("Keys Down: {:08X}", static_cast<u32>(kDown & 0x0FFFFFFF)));
 
     // Clear VM state.
     ResetState();
 
     // Loop until program finishes.
     while (DecodeNextOpcode(cur_opcode)) {
-        callbacks->CommandLog(
+        manager.CommandLog(
             fmt::format("Instruction Ptr: {:04X}", static_cast<u32>(instruction_ptr)));
 
         for (std::size_t i = 0; i < NumRegisters; i++) {
-            callbacks->CommandLog(fmt::format("Registers[{:02X}]: {:016X}", i, registers[i]));
+            manager.CommandLog(fmt::format("Registers[{:02X}]: {:016X}", i, registers[i]));
         }
 
         for (std::size_t i = 0; i < NumRegisters; i++) {
-            callbacks->CommandLog(fmt::format("SavedRegs[{:02X}]: {:016X}", i, saved_values[i]));
+            manager.CommandLog(fmt::format("SavedRegs[{:02X}]: {:016X}", i, saved_values[i]));
         }
         LogOpcode(cur_opcode);
 
@@ -773,7 +768,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryWriteUnsafe(dst_address, &dst_value, store_static->bit_width);
+                manager.WriteCheatProcessMemoryUnsafe(dst_address, &dst_value,
+                                                      store_static->bit_width);
                 break;
             }
         } else if (auto begin_cond = std::get_if<BeginConditionalOpcode>(&cur_opcode.opcode)) {
@@ -786,7 +782,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryReadUnsafe(src_address, &src_value, begin_cond->bit_width);
+                manager.ReadCheatProcessMemoryUnsafe(src_address, &src_value,
+                                                     begin_cond->bit_width);
                 break;
             }
             // Check against condition.
@@ -857,8 +854,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryReadUnsafe(src_address, &registers[ldr_memory->reg_index],
-                                            ldr_memory->bit_width);
+                manager.ReadCheatProcessMemoryUnsafe(src_address, &registers[ldr_memory->reg_index],
+                                                     ldr_memory->bit_width);
                 break;
             }
         } else if (auto str_static = std::get_if<StoreStaticToAddressOpcode>(&cur_opcode.opcode)) {
@@ -874,7 +871,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryWriteUnsafe(dst_address, &dst_value, str_static->bit_width);
+                manager.WriteCheatProcessMemoryUnsafe(dst_address, &dst_value,
+                                                      str_static->bit_width);
                 break;
             }
             // Increment register if relevant.
@@ -1032,7 +1030,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
             case 2:
             case 4:
             case 8:
-                callbacks->MemoryWriteUnsafe(dst_address, &dst_value, str_register->bit_width);
+                manager.WriteCheatProcessMemoryUnsafe(dst_address, &dst_value,
+                                                      str_register->bit_width);
                 break;
             }
 
@@ -1111,8 +1110,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
                 case 2:
                 case 4:
                 case 8:
-                    callbacks->MemoryReadUnsafe(cond_address, &cond_value,
-                                                begin_reg_cond->bit_width);
+                    manager.ReadCheatProcessMemoryUnsafe(cond_address, &cond_value,
+                                                         begin_reg_cond->bit_width);
                     break;
                 }
             }
@@ -1205,9 +1204,9 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
                 static_registers[rw_static_reg->static_idx] = registers[rw_static_reg->idx];
             }
         } else if (std::holds_alternative<PauseProcessOpcode>(cur_opcode.opcode)) {
-            callbacks->PauseProcess();
+            manager.PauseCheatProcessUnsafe();
         } else if (std::holds_alternative<ResumeProcessOpcode>(cur_opcode.opcode)) {
-            callbacks->ResumeProcess();
+            manager.ResumeCheatProcessUnsafe();
         } else if (auto debug_log = std::get_if<DebugLogOpcode>(&cur_opcode.opcode)) {
             // Read value from memory.
             u64 log_value = 0;
@@ -1254,7 +1253,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
                 case 2:
                 case 4:
                 case 8:
-                    callbacks->MemoryReadUnsafe(val_address, &log_value, debug_log->bit_width);
+                    manager.ReadCheatProcessMemoryUnsafe(val_address, &log_value,
+                                                         debug_log->bit_width);
                     break;
                 }
             }
@@ -1265,4 +1265,4 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
     }
 }
 
-} // namespace Core::Memory
+} // namespace Service::DMNT

src/core/hle/service/dmnt/cheat_virtual_machine.h

@@ -3,13 +3,14 @@
 
 #pragma once
 
+#include <span>
 #include <variant>
-#include <vector>
-#include <fmt/printf.h>
-#include "common/common_types.h"
-#include "core/memory/dmnt_cheat_types.h"
 
-namespace Core::Memory {
+#include "common/common_types.h"
+#include "core/hle/service/dmnt/dmnt_types.h"
+
+namespace Service::DMNT {
+class CheatProcessManager;
 
 enum class CheatVmOpcodeType : u32 {
     StoreStatic = 0,
@@ -259,25 +260,8 @@ struct CheatVmOpcode {
         opcode{};
 };
 
-class DmntCheatVm {
+class CheatVirtualMachine {
 public:
-    /// Helper Type for DmntCheatVm <=> yuzu Interface
-    class Callbacks {
-    public:
-        virtual ~Callbacks();
-
-        virtual void MemoryReadUnsafe(VAddr address, void* data, u64 size) = 0;
-        virtual void MemoryWriteUnsafe(VAddr address, const void* data, u64 size) = 0;
-
-        virtual u64 HidKeysDown() = 0;
-
-        virtual void PauseProcess() = 0;
-        virtual void ResumeProcess() = 0;
-
-        virtual void DebugLog(u8 id, u64 value) = 0;
-        virtual void CommandLog(std::string_view data) = 0;
-    };
-
     static constexpr std::size_t MaximumProgramOpcodeCount = 0x400;
     static constexpr std::size_t NumRegisters = 0x10;
     static constexpr std::size_t NumReadableStaticRegisters = 0x80;
@@ -285,18 +269,43 @@ public:
     static constexpr std::size_t NumStaticRegisters =
         NumReadableStaticRegisters + NumWritableStaticRegisters;
 
-    explicit DmntCheatVm(std::unique_ptr<Callbacks> callbacks_);
-    ~DmntCheatVm();
+    explicit CheatVirtualMachine(CheatProcessManager& cheat_manager);
+    ~CheatVirtualMachine();
 
     std::size_t GetProgramSize() const {
         return this->num_opcodes;
     }
 
-    bool LoadProgram(const std::vector<CheatEntry>& cheats);
+    bool LoadProgram(std::span<const CheatEntry> cheats);
     void Execute(const CheatProcessMetadata& metadata);
 
+    u64 GetStaticRegister(std::size_t register_index) const {
+        return static_registers[register_index];
+    }
+
+    void SetStaticRegister(std::size_t register_index, u64 value) {
+        static_registers[register_index] = value;
+    }
+
+    void ResetStaticRegisters() {
+        static_registers = {};
+    }
+
 private:
-    std::unique_ptr<Callbacks> callbacks;
+    bool DecodeNextOpcode(CheatVmOpcode& out);
+    void SkipConditionalBlock(bool is_if);
+    void ResetState();
+
+    // For implementing the DebugLog opcode.
+    void DebugLog(u32 log_id, u64 value) const;
+
+    void LogOpcode(const CheatVmOpcode& opcode) const;
+
+    static u64 GetVmInt(VmInt value, u32 bit_width);
+    static u64 GetCheatProcessAddress(const CheatProcessMetadata& metadata,
+                                      MemoryAccessType mem_type, u64 rel_address);
+
+    CheatProcessManager& manager;
 
     std::size_t num_opcodes = 0;
     std::size_t instruction_ptr = 0;
@@ -307,19 +316,6 @@ private:
     std::array<u64, NumRegisters> saved_values{};
     std::array<u64, NumStaticRegisters> static_registers{};
     std::array<std::size_t, NumRegisters> loop_tops{};
-
-    bool DecodeNextOpcode(CheatVmOpcode& out);
-    void SkipConditionalBlock(bool is_if);
-    void ResetState();
-
-    // For implementing the DebugLog opcode.
-    void DebugLog(u32 log_id, u64 value);
-
-    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);
 };
 
-}; // namespace Core::Memory
+}; // namespace Service::DMNT

src/core/hle/service/dmnt/dmnt.cpp

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/core.h"
+#include "core/hle/service/dmnt/cheat_interface.h"
+#include "core/hle/service/dmnt/cheat_process_manager.h"
+#include "core/hle/service/dmnt/cheat_virtual_machine.h"
+#include "core/hle/service/dmnt/dmnt.h"
+#include "core/hle/service/server_manager.h"
+
+namespace Service::DMNT {
+
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    auto& cheat_manager = system.GetCheatManager();
+    auto cheat_vm = std::make_unique<CheatVirtualMachine>(cheat_manager);
+    cheat_manager.SetVirtualMachine(std::move(cheat_vm));
+
+    server_manager->RegisterNamedService("dmnt:cht",
+                                         std::make_shared<ICheatInterface>(system, cheat_manager));
+    ServerManager::RunServer(std::move(server_manager));
+}
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/dmnt.h

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+namespace Core {
+class System;
+};
+
+namespace Service::DMNT {
+
+void LoopProcess(Core::System& system);
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/dmnt_results.h

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/result.h"
+
+namespace Service::DMNT {
+
+constexpr Result ResultDebuggingDisabled(ErrorModule::DMNT, 2);
+
+constexpr Result ResultCheatNotAttached(ErrorModule::DMNT, 6500);
+constexpr Result ResultCheatNullBuffer(ErrorModule::DMNT, 6501);
+constexpr Result ResultCheatInvalidBuffer(ErrorModule::DMNT, 6502);
+constexpr Result ResultCheatUnknownId(ErrorModule::DMNT, 6503);
+constexpr Result ResultCheatOutOfResource(ErrorModule::DMNT, 6504);
+constexpr Result ResultCheatInvalid(ErrorModule::DMNT, 6505);
+constexpr Result ResultCheatCannotDisable(ErrorModule::DMNT, 6506);
+constexpr Result ResultFrozenAddressInvalidWidth(ErrorModule::DMNT, 6600);
+constexpr Result ResultFrozenAddressAlreadyExists(ErrorModule::DMNT, 6601);
+constexpr Result ResultFrozenAddressNotFound(ErrorModule::DMNT, 6602);
+constexpr Result ResultFrozenAddressOutOfResource(ErrorModule::DMNT, 6603);
+constexpr Result ResultVirtualMachineInvalidConditionDepth(ErrorModule::DMNT, 6700);
+
+} // namespace Service::DMNT

src/core/hle/service/dmnt/dmnt_types.h

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace Service::DMNT {
+
+struct MemoryRegionExtents {
+    u64 base{};
+    u64 size{};
+};
+static_assert(sizeof(MemoryRegionExtents) == 0x10, "MemoryRegionExtents is an invalid size");
+
+struct CheatProcessMetadata {
+    u64 process_id{};
+    u64 program_id{};
+    MemoryRegionExtents main_nso_extents{};
+    MemoryRegionExtents heap_extents{};
+    MemoryRegionExtents alias_extents{};
+    MemoryRegionExtents aslr_extents{};
+    std::array<u8, 0x20> main_nso_build_id{};
+};
+static_assert(sizeof(CheatProcessMetadata) == 0x70, "CheatProcessMetadata is an invalid size");
+
+struct CheatDefinition {
+    std::array<char, 0x40> readable_name;
+    u32 num_opcodes;
+    std::array<u32, 0x100> opcodes;
+};
+static_assert(sizeof(CheatDefinition) == 0x444, "CheatDefinition is an invalid size");
+
+struct CheatEntry {
+    bool enabled;
+    u32 cheat_id;
+    CheatDefinition definition;
+};
+static_assert(sizeof(CheatEntry) == 0x44C, "CheatEntry is an invalid size");
+static_assert(std::is_trivial_v<CheatEntry>, "CheatEntry type must be trivially copyable.");
+
+struct FrozenAddressValue {
+    u64 value;
+    u8 width;
+};
+static_assert(sizeof(FrozenAddressValue) == 0x10, "FrozenAddressValue is an invalid size");
+
+struct FrozenAddressEntry {
+    u64 address;
+    FrozenAddressValue value;
+};
+static_assert(sizeof(FrozenAddressEntry) == 0x18, "FrozenAddressEntry is an invalid size");
+
+} // namespace Service::DMNT

src/core/hle/service/erpt/erpt.cpp

@@ -18,7 +18,7 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, C<&ErrorReportContext::SubmitContext>, "SubmitContext"},
-            {1, C<&ErrorReportContext::CreateReportV0>, "CreateReportV0"},
+            {1, nullptr, "CreateReportV0"},
             {2, nullptr, "SetInitialLaunchSettingsCompletionTime"},
             {3, nullptr, "ClearInitialLaunchSettingsCompletionTime"},
             {4, nullptr, "UpdatePowerOnTime"},
@@ -28,8 +28,7 @@ public:
             {8, nullptr, "ClearApplicationLaunchTime"},
             {9, nullptr, "SubmitAttachment"},
             {10, nullptr, "CreateReportWithAttachments"},
-            {11, C<&ErrorReportContext::CreateReportV1>, "CreateReportV1"},
-            {12, C<&ErrorReportContext::CreateReport>, "CreateReport"},
+            {11, nullptr, "CreateReport"},
             {20, nullptr, "RegisterRunningApplet"},
             {21, nullptr, "UnregisterRunningApplet"},
             {22, nullptr, "UpdateAppletSuspendedDuration"},
@@ -41,37 +40,10 @@ public:
     }
 
 private:
-    Result SubmitContext(InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                         InBuffer<BufferAttr_HipcMapAlias> field_list) {
-        LOG_WARNING(Service_SET, "(STUBBED) called, context_entry_size={}, field_list_size={}",
-                    context_entry.size(), field_list.size());
-        R_SUCCEED();
-    }
-
-    Result CreateReportV0(u32 report_type, InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                          InBuffer<BufferAttr_HipcMapAlias> report_list,
-                          InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
-        LOG_WARNING(Service_SET, "(STUBBED) called, report_type={:#x}", report_type);
-        R_SUCCEED();
-    }
-
-    Result CreateReportV1(u32 report_type, u32 unknown,
-                          InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                          InBuffer<BufferAttr_HipcMapAlias> report_list,
-                          InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
-        LOG_WARNING(Service_SET, "(STUBBED) called, report_type={:#x}, unknown={:#x}", report_type,
-                    unknown);
-        R_SUCCEED();
-    }
-
-    Result CreateReport(u32 report_type, u32 unknown, u32 create_report_option_flag,
-                        InBuffer<BufferAttr_HipcMapAlias> context_entry,
-                        InBuffer<BufferAttr_HipcMapAlias> report_list,
-                        InBuffer<BufferAttr_HipcMapAlias> report_meta_data) {
-        LOG_WARNING(
-            Service_SET,
-            "(STUBBED) called, report_type={:#x}, unknown={:#x}, create_report_option_flag={:#x}",
-            report_type, unknown, create_report_option_flag);
+    Result SubmitContext(InBuffer<BufferAttr_HipcMapAlias> buffer_a,
+                         InBuffer<BufferAttr_HipcMapAlias> buffer_b) {
+        LOG_WARNING(Service_SET, "(STUBBED) called, buffer_a_size={}, buffer_b_size={}",
+                    buffer_a.size(), buffer_b.size());
         R_SUCCEED();
     }
 };

src/core/hle/service/filesystem/fsp/fsp_srv.cpp

@@ -71,7 +71,7 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {28, nullptr, "DeleteSaveDataFileSystemBySaveDataAttribute"},
         {30, nullptr, "OpenGameCardStorage"},
         {31, nullptr, "OpenGameCardFileSystem"},
-        {32, D<&FSP_SRV::ExtendSaveDataFileSystem>, "ExtendSaveDataFileSystem"},
+        {32, nullptr, "ExtendSaveDataFileSystem"},
         {33, nullptr, "DeleteCacheStorage"},
         {34, D<&FSP_SRV::GetCacheStorageSize>, "GetCacheStorageSize"},
         {35, nullptr, "CreateSaveDataFileSystemByHashSalt"},
@@ -79,9 +79,9 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {51, D<&FSP_SRV::OpenSaveDataFileSystem>, "OpenSaveDataFileSystem"},
         {52, D<&FSP_SRV::OpenSaveDataFileSystemBySystemSaveDataId>, "OpenSaveDataFileSystemBySystemSaveDataId"},
         {53, D<&FSP_SRV::OpenReadOnlySaveDataFileSystem>, "OpenReadOnlySaveDataFileSystem"},
-        {57, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataSpaceId>, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
-        {58, D<&FSP_SRV::ReadSaveDataFileSystemExtraData>, "ReadSaveDataFileSystemExtraData"},
-        {59, D<&FSP_SRV::WriteSaveDataFileSystemExtraData>, "WriteSaveDataFileSystemExtraData"},
+        {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
+        {58, nullptr, "ReadSaveDataFileSystemExtraData"},
+        {59, nullptr, "WriteSaveDataFileSystemExtraData"},
         {60, nullptr, "OpenSaveDataInfoReader"},
         {61, D<&FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId>, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
         {62, D<&FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage>, "OpenSaveDataInfoReaderOnlyCacheStorage"},
@@ -90,8 +90,8 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
         {67, D<&FSP_SRV::FindSaveDataWithFilter>, "FindSaveDataWithFilter"},
         {68, nullptr, "OpenSaveDataInfoReaderBySaveDataFilter"},
-        {69, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataAttribute>, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
-        {70, D<&FSP_SRV::WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute>, "WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
+        {69, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataAttribute"},
+        {70, D<&FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute>, "WriteSaveDataFileSystemExtraDataBySaveDataAttribute"},
         {71, D<&FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute>, "ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute"},
         {80, nullptr, "OpenSaveDataMetaFile"},
         {81, nullptr, "OpenSaveDataTransferManager"},
@@ -317,23 +317,9 @@ Result FSP_SRV::FindSaveDataWithFilter(Out<s64> out_count,
     R_THROW(FileSys::ResultTargetNotFound);
 }
 
-Result FSP_SRV::WriteSaveDataFileSystemExtraData(InBuffer<BufferAttr_HipcMapAlias> buffer,
-                                                 FileSys::SaveDataSpaceId space_id,
-                                                 u64 save_data_id) {
-    LOG_WARNING(Service_FS, "(STUBBED) called, space_id={}, save_data_id={:016X}", space_id,
-                save_data_id);
-    R_SUCCEED();
-}
+Result FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute() {
+    LOG_WARNING(Service_FS, "(STUBBED) called.");
 
-Result FSP_SRV::WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
-    InBuffer<BufferAttr_HipcMapAlias> buffer, InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
-    FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute) {
-    LOG_WARNING(Service_FS,
-                "(STUBBED) called, space_id={}, attribute.program_id={:016X}\n"
-                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
-                "attribute.type={}, attribute.rank={}, attribute.index={}",
-                space_id, attribute.program_id, attribute.user_id[1], attribute.user_id[0],
-                attribute.system_save_data_id, attribute.type, attribute.rank, attribute.index);
     R_SUCCEED();
 }
 
@@ -355,38 +341,6 @@ Result FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
     R_SUCCEED();
 }
 
-Result FSP_SRV::ReadSaveDataFileSystemExtraData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                                                u64 save_data_id) {
-    // Stub, backend needs an impl to read/write the SaveDataExtraData
-    LOG_WARNING(Service_FS, "(STUBBED) called, save_data_id={:016X}", save_data_id);
-    std::memset(out_buffer.data(), 0, out_buffer.size());
-    R_SUCCEED();
-}
-
-Result FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataAttribute(
-    OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-    FileSys::SaveDataAttribute attribute) {
-    // Stub, backend needs an impl to read/write the SaveDataExtraData
-    LOG_WARNING(Service_FS,
-                "(STUBBED) called, space_id={}, attribute.program_id={:016X}\n"
-                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
-                "attribute.type={}, attribute.rank={}, attribute.index={}",
-                space_id, attribute.program_id, attribute.user_id[1], attribute.user_id[0],
-                attribute.system_save_data_id, attribute.type, attribute.rank, attribute.index);
-    std::memset(out_buffer.data(), 0, out_buffer.size());
-    R_SUCCEED();
-}
-
-Result FSP_SRV::ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(
-    OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-    u64 save_data_id) {
-    // Stub, backend needs an impl to read/write the SaveDataExtraData
-    LOG_WARNING(Service_FS, "(STUBBED) called, space_id={}, save_data_id={:016X}", space_id,
-                save_data_id);
-    std::memset(out_buffer.data(), 0, out_buffer.size());
-    R_SUCCEED();
-}
-
 Result FSP_SRV::OpenSaveDataTransferProhibiter(
     OutInterface<ISaveDataTransferProhibiter> out_prohibiter, u64 id) {
     LOG_WARNING(Service_FS, "(STUBBED) called, id={:016X}", id);
@@ -522,16 +476,6 @@ Result FSP_SRV::FlushAccessLogOnSdCard() {
     R_SUCCEED();
 }
 
-Result FSP_SRV::ExtendSaveDataFileSystem(FileSys::SaveDataSpaceId space_id, u64 save_data_id,
-                                         s64 available_size, s64 journal_size) {
-    // We don't have an index of save data ids, so we can't implement this.
-    LOG_WARNING(Service_FS,
-                "(STUBBED) called, space_id={}, save_data_id={:016X}, available_size={:#x}, "
-                "journal_size={:#x}",
-                space_id, save_data_id, available_size, journal_size);
-    R_SUCCEED();
-}
-
 Result FSP_SRV::GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size) {
     LOG_WARNING(Service_FS, "(STUBBED) called with index={}", index);
 

src/core/hle/service/filesystem/fsp/fsp_srv.h

@@ -70,19 +70,7 @@ private:
     Result FindSaveDataWithFilter(Out<s64> out_count, OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
                                   FileSys::SaveDataSpaceId space_id,
                                   FileSys::SaveDataFilter filter);
-    Result WriteSaveDataFileSystemExtraData(InBuffer<BufferAttr_HipcMapAlias> buffer,
-                                            FileSys::SaveDataSpaceId space_id, u64 save_data_id);
-    Result WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
-        InBuffer<BufferAttr_HipcMapAlias> buffer, InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
-        FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute);
-    Result ReadSaveDataFileSystemExtraData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                                           u64 save_data_id);
-    Result ReadSaveDataFileSystemExtraDataBySaveDataAttribute(
-        OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-        FileSys::SaveDataAttribute attribute);
-    Result ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(
-        OutBuffer<BufferAttr_HipcMapAlias> out_buffer, FileSys::SaveDataSpaceId space_id,
-        u64 save_data_id);
+    Result WriteSaveDataFileSystemExtraDataBySaveDataAttribute();
     Result ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
         FileSys::SaveDataSpaceId space_id, FileSys::SaveDataAttribute attribute,
         InBuffer<BufferAttr_HipcMapAlias> mask_buffer,
@@ -103,8 +91,6 @@ private:
     Result GetProgramIndexForAccessLog(Out<AccessLogVersion> out_access_log_version,
                                        Out<u32> out_access_log_program_index);
     Result OpenMultiCommitManager(OutInterface<IMultiCommitManager> out_interface);
-    Result ExtendSaveDataFileSystem(FileSys::SaveDataSpaceId space_id, u64 save_data_id,
-                                    s64 available_size, s64 journal_size);
     Result GetCacheStorageSize(s32 index, Out<s64> out_data_size, Out<s64> out_journal_size);
 
     FileSystemController& fsc;

src/core/hle/service/glue/time/manager.cpp

@@ -51,17 +51,16 @@ s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
 }
 
 s64 GetEpochTimeFromInitialYear(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) {
-    s32 year{2000};
-    set_sys->GetSettingsItemValueImpl(year, "time", "standard_user_clock_initial_year");
-
     Service::PSC::Time::CalendarTime calendar{
-        .year = static_cast<s16>(year),
+        .year = 2000,
         .month = 1,
         .day = 1,
         .hour = 0,
         .minute = 0,
         .second = 0,
     };
+    set_sys->GetSettingsItemValueImpl<s16>(calendar.year, "time",
+                                           "standard_user_clock_initial_year");
     return CalendarTimeToEpoch(calendar);
 }
 

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

@@ -1,53 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "common/logging/log.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/hid/active_vibration_device_list.h"
-#include "hid_core/hid_result.h"
-#include "hid_core/hid_util.h"
-#include "hid_core/resource_manager.h"
-#include "hid_core/resources/vibration/vibration_device.h"
-
-namespace Service::HID {
-
-IActiveVibrationDeviceList::IActiveVibrationDeviceList(Core::System& system_,
-                                                       std::shared_ptr<ResourceManager> resource)
-    : ServiceFramework{system_, "IActiveVibrationDeviceList"}, resource_manager(resource) {
-    // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, C<&IActiveVibrationDeviceList::ActivateVibrationDevice>, "ActivateVibrationDevice"},
-        };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IActiveVibrationDeviceList::~IActiveVibrationDeviceList() = default;
-
-Result IActiveVibrationDeviceList::ActivateVibrationDevice(
-    Core::HID::VibrationDeviceHandle vibration_device_handle) {
-    LOG_DEBUG(Service_HID, "called, npad_type={}, npad_id={}, device_index={}",
-              vibration_device_handle.npad_type, vibration_device_handle.npad_id,
-              vibration_device_handle.device_index);
-
-    std::scoped_lock lock{mutex};
-
-    R_TRY(IsVibrationHandleValid(vibration_device_handle));
-
-    for (std::size_t i = 0; i < list_size; i++) {
-        if (vibration_device_handle.device_index == vibration_device_list[i].device_index &&
-            vibration_device_handle.npad_id == vibration_device_list[i].npad_id &&
-            vibration_device_handle.npad_type == vibration_device_list[i].npad_type) {
-            R_SUCCEED();
-        }
-    }
-
-    R_UNLESS(list_size < MaxVibrationDevicesHandles, ResultVibrationDeviceIndexOutOfRange);
-    R_TRY(resource_manager->GetVibrationDevice(vibration_device_handle)->Activate());
-
-    vibration_device_list[list_size++] = vibration_device_handle;
-    R_SUCCEED();
-}
-
-} // namespace Service::HID

src/core/hle/service/hid/active_vibration_device_list.h

@@ -1,39 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <mutex>
-
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-#include "hid_core/hid_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::HID {
-class ResourceManager;
-
-class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {
-public:
-    explicit IActiveVibrationDeviceList(Core::System& system_,
-                                        std::shared_ptr<ResourceManager> resource);
-    ~IActiveVibrationDeviceList() override;
-
-private:
-    static constexpr std::size_t MaxVibrationDevicesHandles{0x100};
-
-    Result ActivateVibrationDevice(Core::HID::VibrationDeviceHandle vibration_device_handle);
-
-    mutable std::mutex mutex;
-    std::size_t list_size{};
-    std::array<Core::HID::VibrationDeviceHandle, MaxVibrationDevicesHandles>
-        vibration_device_list{};
-    std::shared_ptr<ResourceManager> resource_manager;
-};
-
-} // namespace Service::HID

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

@@ -1,34 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "common/logging/log.h"
-#include "core/hle/kernel/k_shared_memory.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/hid/applet_resource.h"
-#include "hid_core/resource_manager.h"
-
-namespace Service::HID {
-
-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, C<&IAppletResource::GetSharedMemoryHandle>, "GetSharedMemoryHandle"},
-    };
-    RegisterHandlers(functions);
-}
-
-IAppletResource::~IAppletResource() {
-    resource_manager->FreeAppletResourceId(aruid);
-}
-
-Result IAppletResource::GetSharedMemoryHandle(
-    OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle) {
-    const auto result = resource_manager->GetSharedMemoryHandle(out_shared_memory_handle, aruid);
-
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, result=0x{:X}", aruid, result.raw);
-    R_RETURN(result);
-}
-
-} // namespace Service::HID

src/core/hle/service/hid/applet_resource.h

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <memory>
-
-#include "common/common_types.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Kernel {
-class KSharedMemory;
-}
-
-namespace Service::HID {
-class ResourceManager;
-
-class IAppletResource final : public ServiceFramework<IAppletResource> {
-public:
-    explicit IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource,
-                             u64 applet_resource_user_id);
-    ~IAppletResource() override;
-
-private:
-    Result GetSharedMemoryHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle);
-
-    u64 aruid{};
-    std::shared_ptr<ResourceManager> resource_manager;
-};
-
-} // namespace Service::HID

src/core/hle/service/hid/hid_server.h

@@ -6,20 +6,12 @@
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 #include "hid_core/hid_types.h"
-#include "hid_core/resources/npad/npad_types.h"
-#include "hid_core/resources/palma/palma.h"
 
 namespace Core {
 class System;
 }
 
-namespace Kernel {
-class KReadableEvent;
-}
-
 namespace Service::HID {
-class IActiveVibrationDeviceList;
-class IAppletResource;
 class ResourceManager;
 class HidFirmwareSettings;
 
@@ -32,232 +24,128 @@ public:
     std::shared_ptr<ResourceManager> GetResourceManager();
 
 private:
-    Result CreateAppletResource(OutInterface<IAppletResource> out_applet_resource,
-                                ClientAppletResourceUserId aruid);
-    Result ActivateDebugPad(ClientAppletResourceUserId aruid);
-    Result ActivateTouchScreen(ClientAppletResourceUserId aruid);
-    Result ActivateMouse(ClientAppletResourceUserId aruid);
-    Result ActivateKeyboard(ClientAppletResourceUserId aruid);
-    Result SendKeyboardLockKeyEvent(u32 flags);
-    Result AcquireXpadIdEventHandle(OutCopyHandle<Kernel::KReadableEvent> out_event,
-                                    ClientAppletResourceUserId aruid);
-    Result ReleaseXpadIdEventHandle(ClientAppletResourceUserId aruid);
-    Result ActivateXpad(u32 basic_xpad_id, ClientAppletResourceUserId aruid);
-    Result GetXpadIds(Out<u64> out_count, OutArray<u32, BufferAttr_HipcPointer> out_basic_pad_ids);
-    Result ActivateJoyXpad(u32 joy_xpad_id);
-    Result GetJoyXpadLifoHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle,
-                                u32 joy_xpad_id);
-    Result GetJoyXpadIds(Out<s64> out_basic_xpad_id_count);
-    Result ActivateSixAxisSensor(u32 joy_xpad_id);
-    Result DeactivateSixAxisSensor(u32 joy_xpad_id);
-    Result GetSixAxisSensorLifoHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle,
-                                      u32 joy_xpad_id);
-    Result ActivateJoySixAxisSensor(u32 joy_xpad_id);
-    Result DeactivateJoySixAxisSensor(u32 joy_xpad_id);
-    Result GetJoySixAxisSensorLifoHandle(
-        OutCopyHandle<Kernel::KSharedMemory> out_shared_memory_handle, u32 joy_xpad_id);
-    Result StartSixAxisSensor(Core::HID::SixAxisSensorHandle sixaxis_handle,
-                              ClientAppletResourceUserId aruid);
-    Result StopSixAxisSensor(Core::HID::SixAxisSensorHandle sixaxis_handle,
-                             ClientAppletResourceUserId aruid);
-    Result IsSixAxisSensorFusionEnabled(Out<bool> out_is_enabled,
-                                        Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                        ClientAppletResourceUserId aruid);
-    Result EnableSixAxisSensorFusion(bool is_enabled, Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                     ClientAppletResourceUserId aruid);
-    Result SetSixAxisSensorFusionParameters(Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                            Core::HID::SixAxisSensorFusionParameters sixaxis_fusion,
-                                            ClientAppletResourceUserId aruid);
-    Result GetSixAxisSensorFusionParameters(
-        Out<Core::HID::SixAxisSensorFusionParameters> out_fusion_parameters,
-        Core::HID::SixAxisSensorHandle sixaxis_handle, ClientAppletResourceUserId aruid);
-    Result ResetSixAxisSensorFusionParameters(Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                              ClientAppletResourceUserId aruid);
-    Result SetGyroscopeZeroDriftMode(Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                     Core::HID::GyroscopeZeroDriftMode drift_mode,
-                                     ClientAppletResourceUserId aruid);
-    Result GetGyroscopeZeroDriftMode(Out<Core::HID::GyroscopeZeroDriftMode> out_drift_mode,
-                                     Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                     ClientAppletResourceUserId aruid);
-    Result ResetGyroscopeZeroDriftMode(Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                       ClientAppletResourceUserId aruid);
-    Result IsSixAxisSensorAtRest(Out<bool> out_is_at_rest,
-                                 Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                 ClientAppletResourceUserId aruid);
-    Result IsFirmwareUpdateAvailableForSixAxisSensor(Out<bool> out_is_firmware_available,
-                                                     Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                                     ClientAppletResourceUserId aruid);
-    Result EnableSixAxisSensorUnalteredPassthrough(bool is_enabled,
-                                                   Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                                   ClientAppletResourceUserId aruid);
-    Result IsSixAxisSensorUnalteredPassthroughEnabled(Out<bool> out_is_enabled,
-                                                      Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                                      ClientAppletResourceUserId aruid);
-    Result LoadSixAxisSensorCalibrationParameter(
-        OutLargeData<Core::HID::SixAxisSensorCalibrationParameter, BufferAttr_HipcMapAlias>
-            out_calibration,
-        Core::HID::SixAxisSensorHandle sixaxis_handle, ClientAppletResourceUserId aruid);
-    Result GetSixAxisSensorIcInformation(
-        OutLargeData<Core::HID::SixAxisSensorIcInformation, BufferAttr_HipcPointer>
-            out_ic_information,
-        Core::HID::SixAxisSensorHandle sixaxis_handle, ClientAppletResourceUserId aruid);
-    Result ResetIsSixAxisSensorDeviceNewlyAssigned(Core::HID::SixAxisSensorHandle sixaxis_handle,
-                                                   ClientAppletResourceUserId aruid);
-    Result ActivateGesture(u32 basic_gesture_id, ClientAppletResourceUserId aruid);
-    Result SetSupportedNpadStyleSet(Core::HID::NpadStyleSet supported_style_set,
-                                    ClientAppletResourceUserId aruid);
-    Result GetSupportedNpadStyleSet(Out<Core::HID::NpadStyleSet> out_supported_style_set,
-                                    ClientAppletResourceUserId aruid);
-    Result SetSupportedNpadIdType(
-        ClientAppletResourceUserId aruid,
-        InArray<Core::HID::NpadIdType, BufferAttr_HipcPointer> supported_npad_list);
-    Result ActivateNpad(ClientAppletResourceUserId aruid);
-    Result DeactivateNpad(ClientAppletResourceUserId aruid);
-    Result AcquireNpadStyleSetUpdateEventHandle(OutCopyHandle<Kernel::KReadableEvent> out_event,
-                                                Core::HID::NpadIdType npad_id,
-                                                ClientAppletResourceUserId aruid, u64 unknown);
-    Result DisconnectNpad(Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid);
+    void CreateAppletResource(HLERequestContext& ctx);
+    void ActivateDebugPad(HLERequestContext& ctx);
+    void ActivateTouchScreen(HLERequestContext& ctx);
+    void ActivateMouse(HLERequestContext& ctx);
+    void ActivateKeyboard(HLERequestContext& ctx);
+    void SendKeyboardLockKeyEvent(HLERequestContext& ctx);
+    void AcquireXpadIdEventHandle(HLERequestContext& ctx);
+    void ReleaseXpadIdEventHandle(HLERequestContext& ctx);
+    void ActivateXpad(HLERequestContext& ctx);
+    void GetXpadIds(HLERequestContext& ctx);
+    void ActivateJoyXpad(HLERequestContext& ctx);
+    void GetJoyXpadLifoHandle(HLERequestContext& ctx);
+    void GetJoyXpadIds(HLERequestContext& ctx);
+    void ActivateSixAxisSensor(HLERequestContext& ctx);
+    void DeactivateSixAxisSensor(HLERequestContext& ctx);
+    void GetSixAxisSensorLifoHandle(HLERequestContext& ctx);
+    void ActivateJoySixAxisSensor(HLERequestContext& ctx);
+    void DeactivateJoySixAxisSensor(HLERequestContext& ctx);
+    void GetJoySixAxisSensorLifoHandle(HLERequestContext& ctx);
+    void StartSixAxisSensor(HLERequestContext& ctx);
+    void StopSixAxisSensor(HLERequestContext& ctx);
+    void IsSixAxisSensorFusionEnabled(HLERequestContext& ctx);
+    void EnableSixAxisSensorFusion(HLERequestContext& ctx);
+    void SetSixAxisSensorFusionParameters(HLERequestContext& ctx);
+    void GetSixAxisSensorFusionParameters(HLERequestContext& ctx);
+    void ResetSixAxisSensorFusionParameters(HLERequestContext& ctx);
+    void SetGyroscopeZeroDriftMode(HLERequestContext& ctx);
+    void GetGyroscopeZeroDriftMode(HLERequestContext& ctx);
+    void ResetGyroscopeZeroDriftMode(HLERequestContext& ctx);
+    void IsSixAxisSensorAtRest(HLERequestContext& ctx);
+    void IsFirmwareUpdateAvailableForSixAxisSensor(HLERequestContext& ctx);
+    void EnableSixAxisSensorUnalteredPassthrough(HLERequestContext& ctx);
+    void IsSixAxisSensorUnalteredPassthroughEnabled(HLERequestContext& ctx);
+    void LoadSixAxisSensorCalibrationParameter(HLERequestContext& ctx);
+    void GetSixAxisSensorIcInformation(HLERequestContext& ctx);
+    void ResetIsSixAxisSensorDeviceNewlyAssigned(HLERequestContext& ctx);
+    void ActivateGesture(HLERequestContext& ctx);
+    void SetSupportedNpadStyleSet(HLERequestContext& ctx);
+    void GetSupportedNpadStyleSet(HLERequestContext& ctx);
+    void SetSupportedNpadIdType(HLERequestContext& ctx);
+    void ActivateNpad(HLERequestContext& ctx);
+    void DeactivateNpad(HLERequestContext& ctx);
+    void AcquireNpadStyleSetUpdateEventHandle(HLERequestContext& ctx);
+    void DisconnectNpad(HLERequestContext& ctx);
     Result GetPlayerLedPattern(Out<Core::HID::LedPattern> out_led_pattern,
                                Core::HID::NpadIdType npad_id);
-    Result ActivateNpadWithRevision(NpadRevision revision, ClientAppletResourceUserId aruid);
-    Result SetNpadJoyHoldType(ClientAppletResourceUserId aruid, NpadJoyHoldType hold_type);
-    Result GetNpadJoyHoldType(Out<NpadJoyHoldType> out_hold_type, ClientAppletResourceUserId aruid);
-    Result SetNpadJoyAssignmentModeSingleByDefault(Core::HID::NpadIdType npad_id,
-                                                   ClientAppletResourceUserId aruid);
-    Result SetNpadJoyAssignmentModeSingle(Core::HID::NpadIdType npad_id,
-                                          ClientAppletResourceUserId aruid,
-                                          NpadJoyDeviceType npad_joy_device_type);
-    Result SetNpadJoyAssignmentModeDual(Core::HID::NpadIdType npad_id,
-                                        ClientAppletResourceUserId aruid);
-    Result MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2,
-                                   ClientAppletResourceUserId aruid);
-    Result StartLrAssignmentMode(ClientAppletResourceUserId aruid);
-    Result StopLrAssignmentMode(ClientAppletResourceUserId aruid);
-    Result SetNpadHandheldActivationMode(ClientAppletResourceUserId aruid,
-                                         NpadHandheldActivationMode activation_mode);
-    Result GetNpadHandheldActivationMode(Out<NpadHandheldActivationMode> out_activation_mode,
-                                         ClientAppletResourceUserId aruid);
-    Result SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2,
-                              ClientAppletResourceUserId aruid);
-    Result IsUnintendedHomeButtonInputProtectionEnabled(Out<bool> out_is_enabled,
-                                                        Core::HID::NpadIdType npad_id,
-                                                        ClientAppletResourceUserId aruid);
-    Result EnableUnintendedHomeButtonInputProtection(bool is_enabled, Core::HID::NpadIdType npad_id,
-                                                     ClientAppletResourceUserId aruid);
-    Result SetNpadJoyAssignmentModeSingleWithDestination(Out<bool> out_is_reassigned,
-                                                         Out<Core::HID::NpadIdType> out_new_npad_id,
-                                                         Core::HID::NpadIdType npad_id,
-                                                         ClientAppletResourceUserId aruid,
-                                                         NpadJoyDeviceType npad_joy_device_type);
-    Result SetNpadAnalogStickUseCenterClamp(bool use_center_clamp,
-                                            ClientAppletResourceUserId aruid);
-    Result SetNpadCaptureButtonAssignment(Core::HID::NpadStyleSet npad_styleset,
-                                          ClientAppletResourceUserId aruid,
-                                          Core::HID::NpadButton button);
-    Result ClearNpadCaptureButtonAssignment(ClientAppletResourceUserId aruid);
-    Result GetVibrationDeviceInfo(Out<Core::HID::VibrationDeviceInfo> out_vibration_device_info,
-                                  Core::HID::VibrationDeviceHandle vibration_device_handle);
-    Result SendVibrationValue(Core::HID::VibrationDeviceHandle vibration_device_handle,
-                              Core::HID::VibrationValue vibration_value,
-                              ClientAppletResourceUserId aruid);
-    Result GetActualVibrationValue(Out<Core::HID::VibrationValue> out_vibration_value,
-                                   Core::HID::VibrationDeviceHandle vibration_device_handle,
-                                   ClientAppletResourceUserId aruid);
-    Result CreateActiveVibrationDeviceList(OutInterface<IActiveVibrationDeviceList> out_interface);
-    Result PermitVibration(bool can_vibrate);
-    Result IsVibrationPermitted(Out<bool> out_is_permitted);
-    Result SendVibrationValues(
-        ClientAppletResourceUserId aruid,
-        InArray<Core::HID::VibrationDeviceHandle, BufferAttr_HipcPointer> vibration_handles,
-        InArray<Core::HID::VibrationValue, BufferAttr_HipcPointer> vibration_values);
-    Result SendVibrationGcErmCommand(Core::HID::VibrationDeviceHandle vibration_device_handle,
-                                     ClientAppletResourceUserId aruid,
-                                     Core::HID::VibrationGcErmCommand gc_erm_command);
-    Result GetActualVibrationGcErmCommand(Out<Core::HID::VibrationGcErmCommand> out_gc_erm_command,
-                                          Core::HID::VibrationDeviceHandle vibration_device_handle,
-                                          ClientAppletResourceUserId aruid);
-    Result BeginPermitVibrationSession(ClientAppletResourceUserId aruid);
-    Result EndPermitVibrationSession(ClientAppletResourceUserId aruid);
-    Result IsVibrationDeviceMounted(Out<bool> out_is_mounted,
-                                    Core::HID::VibrationDeviceHandle vibration_device_handle,
-                                    ClientAppletResourceUserId aruid);
-    Result SendVibrationValueInBool(bool is_vibrating,
-                                    Core::HID::VibrationDeviceHandle vibration_device_handle,
-                                    ClientAppletResourceUserId aruid);
-    Result ActivateConsoleSixAxisSensor(ClientAppletResourceUserId aruid);
-    Result StartConsoleSixAxisSensor(Core::HID::ConsoleSixAxisSensorHandle console_sixaxis_handle,
-                                     ClientAppletResourceUserId aruid);
-    Result StopConsoleSixAxisSensor(Core::HID::ConsoleSixAxisSensorHandle console_sixaxis_handle,
-                                    ClientAppletResourceUserId aruid);
-    Result ActivateSevenSixAxisSensor(ClientAppletResourceUserId aruid);
-    Result StartSevenSixAxisSensor(ClientAppletResourceUserId aruid);
-    Result StopSevenSixAxisSensor(ClientAppletResourceUserId aruid);
-    Result InitializeSevenSixAxisSensor(ClientAppletResourceUserId aruid, u64 t_mem_1_size,
-                                        u64 t_mem_2_size,
-                                        InCopyHandle<Kernel::KTransferMemory> t_mem_1,
-                                        InCopyHandle<Kernel::KTransferMemory> t_mem_2);
-    Result FinalizeSevenSixAxisSensor(ClientAppletResourceUserId aruid);
-    Result ResetSevenSixAxisSensorTimestamp(ClientAppletResourceUserId aruid);
-    Result IsUsbFullKeyControllerEnabled(Out<bool> out_is_enabled,
-                                         ClientAppletResourceUserId aruid);
-    Result GetPalmaConnectionHandle(Out<Palma::PalmaConnectionHandle> out_handle,
-                                    Core::HID::NpadIdType npad_id,
-                                    ClientAppletResourceUserId aruid);
-    Result InitializePalma(Palma::PalmaConnectionHandle connection_handle);
-    Result AcquirePalmaOperationCompleteEvent(OutCopyHandle<Kernel::KReadableEvent> out_event,
-                                              Palma::PalmaConnectionHandle connection_handle);
-    Result GetPalmaOperationInfo(Out<Palma::PalmaOperationType> out_operation_type,
-                                 Palma::PalmaConnectionHandle connection_handle,
-                                 OutBuffer<BufferAttr_HipcMapAlias> out_data);
-    Result PlayPalmaActivity(Palma::PalmaConnectionHandle connection_handle, u64 palma_activity);
-    Result SetPalmaFrModeType(Palma::PalmaConnectionHandle connection_handle,
-                              Palma::PalmaFrModeType fr_mode);
-    Result ReadPalmaStep(Palma::PalmaConnectionHandle connection_handle);
-    Result EnablePalmaStep(bool is_enabled, Palma::PalmaConnectionHandle connection_handle);
-    Result ResetPalmaStep(Palma::PalmaConnectionHandle connection_handle);
-    Result ReadPalmaApplicationSection(Palma::PalmaConnectionHandle connection_handle, u64 offset,
-                                       u64 size);
-    Result WritePalmaApplicationSection(
-        Palma::PalmaConnectionHandle connection_handle, u64 offset, u64 size,
-        InLargeData<Palma::PalmaApplicationSection, BufferAttr_HipcPointer> data);
-    Result ReadPalmaUniqueCode(Palma::PalmaConnectionHandle connection_handle);
-    Result SetPalmaUniqueCodeInvalid(Palma::PalmaConnectionHandle connection_handle);
-    Result WritePalmaActivityEntry(Palma::PalmaConnectionHandle connection_handle,
-                                   Palma::PalmaActivityEntry activity_entry);
-    Result WritePalmaRgbLedPatternEntry(Palma::PalmaConnectionHandle connection_handle, u64 unknown,
-                                        InBuffer<BufferAttr_HipcMapAlias> led_pattern);
-    Result WritePalmaWaveEntry(Palma::PalmaConnectionHandle connection_handle,
-                               Palma::PalmaWaveSet wave_set, u64 unknown, u64 t_mem_size, u64 size,
-                               InCopyHandle<Kernel::KTransferMemory> t_mem);
-    Result SetPalmaDataBaseIdentificationVersion(s32 database_id_version,
-                                                 Palma::PalmaConnectionHandle connection_handle);
-    Result GetPalmaDataBaseIdentificationVersion(Palma::PalmaConnectionHandle connection_handle);
-    Result SuspendPalmaFeature(Palma::PalmaFeature feature,
-                               Palma::PalmaConnectionHandle connection_handle);
-    Result GetPalmaOperationResult(Palma::PalmaConnectionHandle connection_handle);
-    Result ReadPalmaPlayLog(u16 unknown, Palma::PalmaConnectionHandle connection_handle);
-    Result ResetPalmaPlayLog(u16 unknown, Palma::PalmaConnectionHandle connection_handle);
-    Result SetIsPalmaAllConnectable(bool is_palma_all_connectable, ClientAppletResourceUserId arui);
-    Result SetIsPalmaPairedConnectable(bool is_palma_paired_connectable,
-                                       ClientAppletResourceUserId aruid);
-    Result PairPalma(Palma::PalmaConnectionHandle connection_handle);
-    Result SetPalmaBoostMode(bool is_enabled);
-    Result CancelWritePalmaWaveEntry(Palma::PalmaConnectionHandle connection_handle);
-    Result EnablePalmaBoostMode(bool is_enabled, ClientAppletResourceUserId aruid);
-    Result GetPalmaBluetoothAddress(Out<Palma::Address> out_bt_address,
-                                    Palma::PalmaConnectionHandle connection_handle);
-    Result SetDisallowedPalmaConnection(
-        ClientAppletResourceUserId aruid,
-        InArray<Palma::Address, BufferAttr_HipcPointer> disallowed_address);
-    Result SetNpadCommunicationMode(ClientAppletResourceUserId aruid,
-                                    NpadCommunicationMode communication_mode);
-    Result GetNpadCommunicationMode(Out<NpadCommunicationMode> out_communication_mode,
-                                    ClientAppletResourceUserId aruid);
-    Result SetTouchScreenConfiguration(Core::HID::TouchScreenConfigurationForNx touchscreen_config,
-                                       ClientAppletResourceUserId aruid);
-    Result IsFirmwareUpdateNeededForNotification(Out<bool> out_is_firmware_update_needed,
-                                                 s32 unknown, ClientAppletResourceUserId aruid);
-    Result SetTouchScreenResolution(u32 width, u32 height, ClientAppletResourceUserId aruid);
+    void ActivateNpadWithRevision(HLERequestContext& ctx);
+    void SetNpadJoyHoldType(HLERequestContext& ctx);
+    void GetNpadJoyHoldType(HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeSingleByDefault(HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeSingle(HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeDual(HLERequestContext& ctx);
+    void MergeSingleJoyAsDualJoy(HLERequestContext& ctx);
+    void StartLrAssignmentMode(HLERequestContext& ctx);
+    void StopLrAssignmentMode(HLERequestContext& ctx);
+    void SetNpadHandheldActivationMode(HLERequestContext& ctx);
+    void GetNpadHandheldActivationMode(HLERequestContext& ctx);
+    void SwapNpadAssignment(HLERequestContext& ctx);
+    void IsUnintendedHomeButtonInputProtectionEnabled(HLERequestContext& ctx);
+    void EnableUnintendedHomeButtonInputProtection(HLERequestContext& ctx);
+    void SetNpadJoyAssignmentModeSingleWithDestination(HLERequestContext& ctx);
+    void SetNpadAnalogStickUseCenterClamp(HLERequestContext& ctx);
+    void SetNpadCaptureButtonAssignment(HLERequestContext& ctx);
+    void ClearNpadCaptureButtonAssignment(HLERequestContext& ctx);
+    void GetVibrationDeviceInfo(HLERequestContext& ctx);
+    void SendVibrationValue(HLERequestContext& ctx);
+    void GetActualVibrationValue(HLERequestContext& ctx);
+    void CreateActiveVibrationDeviceList(HLERequestContext& ctx);
+    void PermitVibration(HLERequestContext& ctx);
+    void IsVibrationPermitted(HLERequestContext& ctx);
+    void SendVibrationValues(HLERequestContext& ctx);
+    void SendVibrationGcErmCommand(HLERequestContext& ctx);
+    void GetActualVibrationGcErmCommand(HLERequestContext& ctx);
+    void BeginPermitVibrationSession(HLERequestContext& ctx);
+    void EndPermitVibrationSession(HLERequestContext& ctx);
+    void IsVibrationDeviceMounted(HLERequestContext& ctx);
+    void SendVibrationValueInBool(HLERequestContext& ctx);
+    void ActivateConsoleSixAxisSensor(HLERequestContext& ctx);
+    void StartConsoleSixAxisSensor(HLERequestContext& ctx);
+    void StopConsoleSixAxisSensor(HLERequestContext& ctx);
+    void ActivateSevenSixAxisSensor(HLERequestContext& ctx);
+    void StartSevenSixAxisSensor(HLERequestContext& ctx);
+    void StopSevenSixAxisSensor(HLERequestContext& ctx);
+    void InitializeSevenSixAxisSensor(HLERequestContext& ctx);
+    void FinalizeSevenSixAxisSensor(HLERequestContext& ctx);
+    void ResetSevenSixAxisSensorTimestamp(HLERequestContext& ctx);
+    void IsUsbFullKeyControllerEnabled(HLERequestContext& ctx);
+    void GetPalmaConnectionHandle(HLERequestContext& ctx);
+    void InitializePalma(HLERequestContext& ctx);
+    void AcquirePalmaOperationCompleteEvent(HLERequestContext& ctx);
+    void GetPalmaOperationInfo(HLERequestContext& ctx);
+    void PlayPalmaActivity(HLERequestContext& ctx);
+    void SetPalmaFrModeType(HLERequestContext& ctx);
+    void ReadPalmaStep(HLERequestContext& ctx);
+    void EnablePalmaStep(HLERequestContext& ctx);
+    void ResetPalmaStep(HLERequestContext& ctx);
+    void ReadPalmaApplicationSection(HLERequestContext& ctx);
+    void WritePalmaApplicationSection(HLERequestContext& ctx);
+    void ReadPalmaUniqueCode(HLERequestContext& ctx);
+    void SetPalmaUniqueCodeInvalid(HLERequestContext& ctx);
+    void WritePalmaActivityEntry(HLERequestContext& ctx);
+    void WritePalmaRgbLedPatternEntry(HLERequestContext& ctx);
+    void WritePalmaWaveEntry(HLERequestContext& ctx);
+    void SetPalmaDataBaseIdentificationVersion(HLERequestContext& ctx);
+    void GetPalmaDataBaseIdentificationVersion(HLERequestContext& ctx);
+    void SuspendPalmaFeature(HLERequestContext& ctx);
+    void GetPalmaOperationResult(HLERequestContext& ctx);
+    void ReadPalmaPlayLog(HLERequestContext& ctx);
+    void ResetPalmaPlayLog(HLERequestContext& ctx);
+    void SetIsPalmaAllConnectable(HLERequestContext& ctx);
+    void SetIsPalmaPairedConnectable(HLERequestContext& ctx);
+    void PairPalma(HLERequestContext& ctx);
+    void SetPalmaBoostMode(HLERequestContext& ctx);
+    void CancelWritePalmaWaveEntry(HLERequestContext& ctx);
+    void EnablePalmaBoostMode(HLERequestContext& ctx);
+    void GetPalmaBluetoothAddress(HLERequestContext& ctx);
+    void SetDisallowedPalmaConnection(HLERequestContext& ctx);
+    void SetNpadCommunicationMode(HLERequestContext& ctx);
+    void GetNpadCommunicationMode(HLERequestContext& ctx);
+    void SetTouchScreenConfiguration(HLERequestContext& ctx);
+    void IsFirmwareUpdateNeededForNotification(HLERequestContext& ctx);
+    void SetTouchScreenResolution(HLERequestContext& ctx);
 
     std::shared_ptr<ResourceManager> resource_manager;
     std::shared_ptr<HidFirmwareSettings> firmware_settings;

src/core/hle/service/ldn/monitor_service.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ldn/ldn_results.h"
 #include "core/hle/service/ldn/monitor_service.h"
 
 namespace Service::LDN {
@@ -18,7 +17,7 @@ IMonitorService::IMonitorService(Core::System& system_)
         {4, nullptr, "GetSecurityParameterForMonitor"},
         {5, nullptr, "GetNetworkConfigForMonitor"},
         {100, C<&IMonitorService::InitializeMonitor>, "InitializeMonitor"},
-        {101, C<&IMonitorService::FinalizeMonitor>, "FinalizeMonitor"},
+        {101, nullptr, "FinalizeMonitor"},
     };
     // clang-format on
 
@@ -28,18 +27,16 @@ IMonitorService::IMonitorService(Core::System& system_)
 IMonitorService::~IMonitorService() = default;
 
 Result IMonitorService::GetStateForMonitor(Out<State> out_state) {
-    LOG_WARNING(Service_LDN, "(STUBBED) called");
-    *out_state = State::None;
+    LOG_INFO(Service_LDN, "called");
+
+    *out_state = state;
     R_SUCCEED();
 }
 
 Result IMonitorService::InitializeMonitor() {
     LOG_INFO(Service_LDN, "called");
-    R_SUCCEED();
-}
 
-Result IMonitorService::FinalizeMonitor() {
-    LOG_INFO(Service_LDN, "called");
+    state = State::Initialized;
     R_SUCCEED();
 }
 

src/core/hle/service/ldn/monitor_service.h

@@ -21,7 +21,6 @@ public:
 private:
     Result GetStateForMonitor(Out<State> out_state);
     Result InitializeMonitor();
-    Result FinalizeMonitor();
 
     State state{State::None};
 };

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

@@ -5,7 +5,6 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
 #include "core/hle/service/nvdrv/core/syncpoint_manager.h"
@@ -76,7 +75,7 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
         case 0xd:
             return WrapFixed(this, &nvhost_gpu::SetChannelPriority, input, output);
         case 0x1a:
-            return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output, fd);
+            return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output);
         case 0x1b:
             return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, true);
         case 0x1d:
@@ -121,13 +120,8 @@ NvResult nvhost_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     return NvResult::NotImplemented;
 }
 
-void nvhost_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
-    sessions[fd] = session_id;
-}
-
-void nvhost_gpu::OnClose(DeviceFD fd) {
-    sessions.erase(fd);
-}
+void nvhost_gpu::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
+void nvhost_gpu::OnClose(DeviceFD fd) {}
 
 NvResult nvhost_gpu::SetNVMAPfd(IoctlSetNvmapFD& params) {
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
@@ -167,7 +161,7 @@ NvResult nvhost_gpu::SetChannelPriority(IoctlChannelSetPriority& params) {
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd) {
+NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params) {
     LOG_WARNING(Service_NVDRV,
                 "(STUBBED) called, num_entries={:X}, flags={:X}, unk0={:X}, "
                 "unk1={:X}, unk2={:X}, unk3={:X}",
@@ -179,12 +173,7 @@ NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd) {
         return NvResult::AlreadyAllocated;
     }
 
-    u64 program_id{};
-    if (auto* const session = core.GetSession(sessions[fd]); session != nullptr) {
-        program_id = session->process->GetProgramId();
-    }
-
-    system.GPU().InitChannel(*channel_state, program_id);
+    system.GPU().InitChannel(*channel_state);
 
     params.fence_out = syncpoint_manager.GetSyncpointFence(channel_syncpoint);
 

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

@@ -192,7 +192,7 @@ private:
     NvResult ZCullBind(IoctlZCullBind& params);
     NvResult SetErrorNotifier(IoctlSetErrorNotifier& params);
     NvResult SetChannelPriority(IoctlChannelSetPriority& params);
-    NvResult AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params, DeviceFD fd);
+    NvResult AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params);
     NvResult AllocateObjectContext(IoctlAllocObjCtx& params);
 
     NvResult SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandList&& entries);
@@ -210,7 +210,6 @@ private:
     NvCore::SyncpointManager& syncpoint_manager;
     NvCore::NvMap& nvmap;
     std::shared_ptr<Tegra::Control::ChannelState> channel_state;
-    std::unordered_map<DeviceFD, NvCore::SessionId> sessions;
     u32 channel_syncpoint;
     std::mutex channel_mutex;
 

src/core/hle/service/server_manager.cpp

@@ -93,19 +93,13 @@ ServerManager::~ServerManager() {
     m_threads.clear();
 
     // Clean up ports.
-    auto port_it = m_servers.begin();
-    while (port_it != m_servers.end()) {
-        auto* const port = std::addressof(*port_it);
-        port_it = m_servers.erase(port_it);
-        delete port;
+    for (auto it = m_servers.begin(); it != m_servers.end(); it = m_servers.erase(it)) {
+        delete std::addressof(*it);
     }
 
     // Clean up sessions.
-    auto session_it = m_sessions.begin();
-    while (session_it != m_sessions.end()) {
-        auto* const session = std::addressof(*session_it);
-        session_it = m_sessions.erase(session_it);
-        delete session;
+    for (auto it = m_sessions.begin(); it != m_sessions.end(); it = m_sessions.erase(it)) {
+        delete std::addressof(*it);
     }
 
     // Close wakeup event.

src/core/hle/service/services.cpp

@@ -13,6 +13,7 @@
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/btm/btm.h"
 #include "core/hle/service/caps/caps.h"
+#include "core/hle/service/dmnt/dmnt.h"
 #include "core/hle/service/erpt/erpt.h"
 #include "core/hle/service/es/es.h"
 #include "core/hle/service/eupld/eupld.h"
@@ -128,6 +129,7 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
     kernel.RunOnGuestCoreProcess("spl",        [&] { SPL::LoopProcess(system); });
     kernel.RunOnGuestCoreProcess("ssl",        [&] { SSL::LoopProcess(system); });
     kernel.RunOnGuestCoreProcess("usb",        [&] { USB::LoopProcess(system); });
+    kernel.RunOnGuestCoreProcess("dmnt",        [&] { DMNT::LoopProcess(system); });
     // clang-format on
 }
 

src/core/hle/service/set/settings_types.h

@@ -243,11 +243,6 @@ enum class TvResolution : u32 {
     Resolution480p,
 };
 
-enum class PlatformRegion : s32 {
-    Global = 1,
-    Terra = 2,
-};
-
 constexpr std::array<LanguageCode, 18> available_language_codes = {{
     LanguageCode::JA,
     LanguageCode::EN_US,

src/core/hle/service/set/system_settings_server.cpp

@@ -272,8 +272,8 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_)
         {180, nullptr, "SetZoomFlag"},
         {181, nullptr, "GetT"},
         {182, nullptr, "SetT"},
-        {183, C<&ISystemSettingsServer::GetPlatformRegion>, "GetPlatformRegion"},
-        {184, C<&ISystemSettingsServer::SetPlatformRegion>, "SetPlatformRegion"},
+        {183, nullptr, "GetPlatformRegion"},
+        {184, nullptr, "SetPlatformRegion"},
         {185, C<&ISystemSettingsServer::GetHomeMenuSchemeModel>, "GetHomeMenuSchemeModel"},
         {186, nullptr, "GetMemoryUsageRateFlag"},
         {187, C<&ISystemSettingsServer::GetTouchScreenMode>, "GetTouchScreenMode"},
@@ -1250,18 +1250,6 @@ Result ISystemSettingsServer::GetHomeMenuScheme(Out<HomeMenuScheme> out_home_men
     R_SUCCEED();
 }
 
-Result ISystemSettingsServer::GetPlatformRegion(Out<PlatformRegion> out_platform_region) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-
-    *out_platform_region = PlatformRegion::Global;
-    R_SUCCEED();
-}
-
-Result ISystemSettingsServer::SetPlatformRegion(PlatformRegion platform_region) {
-    LOG_WARNING(Service_SET, "(STUBBED) called");
-    R_SUCCEED();
-}
-
 Result ISystemSettingsServer::GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model) {
     LOG_WARNING(Service_SET, "(STUBBED) called");
 

src/core/hle/service/set/system_settings_server.h

@@ -149,8 +149,6 @@ public:
     Result GetHomeMenuScheme(Out<HomeMenuScheme> out_home_menu_scheme);
     Result GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model);
     Result GetTouchScreenMode(Out<TouchScreenMode> out_touch_screen_mode);
-    Result GetPlatformRegion(Out<PlatformRegion> out_platform_region);
-    Result SetPlatformRegion(PlatformRegion platform_region);
     Result SetTouchScreenMode(TouchScreenMode touch_screen_mode);
     Result GetFieldTestingFlag(Out<bool> out_field_testing_flag);
     Result GetPanelCrcMode(Out<s32> out_panel_crc_mode);

src/core/hle/service/ssl/cert_store.cpp

@@ -1,156 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/alignment.h"
-#include "core/core.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/romfs.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/ssl/cert_store.h"
-
-namespace Service::SSL {
-
-// https://switchbrew.org/wiki/SSL_services#CertStore
-
-CertStore::CertStore(Core::System& system) {
-    constexpr u64 CertStoreDataId = 0x0100000000000800ULL;
-
-    auto& fsc = system.GetFileSystemController();
-
-    // Attempt to load certificate data from storage
-    const auto nca =
-        fsc.GetSystemNANDContents()->GetEntry(CertStoreDataId, FileSys::ContentRecordType::Data);
-    if (!nca) {
-        return;
-    }
-    const auto romfs = nca->GetRomFS();
-    if (!romfs) {
-        return;
-    }
-    const auto extracted = FileSys::ExtractRomFS(romfs);
-    if (!extracted) {
-        LOG_ERROR(Service_SSL, "CertStore could not be extracted, corrupt RomFS?");
-        return;
-    }
-    const auto cert_store_file = extracted->GetFile("ssl_TrustedCerts.bdf");
-    if (!cert_store_file) {
-        LOG_ERROR(Service_SSL, "Failed to find trusted certificates in CertStore");
-        return;
-    }
-
-    // Read and verify the header.
-    CertStoreHeader header;
-    cert_store_file->ReadObject(std::addressof(header));
-
-    if (header.magic != Common::MakeMagic('s', 's', 'l', 'T')) {
-        LOG_ERROR(Service_SSL, "Invalid certificate store magic");
-        return;
-    }
-
-    // Ensure the file can contains the number of entries it says it does.
-    const u64 expected_size = sizeof(header) + sizeof(CertStoreEntry) * header.num_entries;
-    const u64 actual_size = cert_store_file->GetSize();
-    if (actual_size < expected_size) {
-        LOG_ERROR(Service_SSL, "Size mismatch, expected at least {} bytes, got {}", expected_size,
-                  actual_size);
-        return;
-    }
-
-    // Read entries.
-    std::vector<CertStoreEntry> entries(header.num_entries);
-    cert_store_file->ReadArray(entries.data(), header.num_entries, sizeof(header));
-
-    // Insert into memory store.
-    for (const auto& entry : entries) {
-        m_certs.emplace(entry.certificate_id,
-                        Certificate{
-                            .status = entry.certificate_status,
-                            .der_data = cert_store_file->ReadBytes(
-                                entry.der_size, entry.der_offset + sizeof(header)),
-                        });
-    }
-}
-
-CertStore::~CertStore() = default;
-
-template <typename F>
-void CertStore::ForEachCertificate(std::span<const CaCertificateId> certificate_ids, F&& f) {
-    if (certificate_ids.size() == 1 && certificate_ids.front() == CaCertificateId::All) {
-        for (const auto& entry : m_certs) {
-            f(entry);
-        }
-    } else {
-        for (const auto certificate_id : certificate_ids) {
-            const auto entry = m_certs.find(certificate_id);
-            if (entry == m_certs.end()) {
-                continue;
-            }
-            f(*entry);
-        }
-    }
-}
-
-Result CertStore::GetCertificates(u32* out_num_entries, std::span<u8> out_data,
-                                  std::span<const CaCertificateId> certificate_ids) {
-    // Ensure the buffer is large enough to hold the output.
-    u32 required_size;
-    R_TRY(this->GetCertificateBufSize(std::addressof(required_size), out_num_entries,
-                                      certificate_ids));
-    R_UNLESS(out_data.size_bytes() >= required_size, ResultUnknown);
-
-    // Make parallel arrays.
-    std::vector<BuiltInCertificateInfo> cert_infos;
-    std::vector<u8> der_datas;
-
-    const u32 der_data_offset = (*out_num_entries + 1) * sizeof(BuiltInCertificateInfo);
-    u32 cur_der_offset = der_data_offset;
-
-    // Fill output.
-    this->ForEachCertificate(certificate_ids, [&](auto& entry) {
-        const auto& [status, cur_der_data] = entry.second;
-        BuiltInCertificateInfo cert_info{
-            .cert_id = entry.first,
-            .status = status,
-            .der_size = cur_der_data.size(),
-            .der_offset = cur_der_offset,
-        };
-
-        cert_infos.push_back(cert_info);
-        der_datas.insert(der_datas.end(), cur_der_data.begin(), cur_der_data.end());
-        cur_der_offset += static_cast<u32>(cur_der_data.size());
-    });
-
-    // Append terminator entry.
-    cert_infos.push_back(BuiltInCertificateInfo{
-        .cert_id = CaCertificateId::All,
-        .status = TrustedCertStatus::Invalid,
-        .der_size = 0,
-        .der_offset = 0,
-    });
-
-    // Write to output span.
-    std::memcpy(out_data.data(), cert_infos.data(),
-                cert_infos.size() * sizeof(BuiltInCertificateInfo));
-    std::memcpy(out_data.data() + der_data_offset, der_datas.data(), der_datas.size());
-
-    R_SUCCEED();
-}
-
-Result CertStore::GetCertificateBufSize(u32* out_size, u32* out_num_entries,
-                                        std::span<const CaCertificateId> certificate_ids) {
-    // Output size is at least the size of the terminator entry.
-    *out_size = sizeof(BuiltInCertificateInfo);
-    *out_num_entries = 0;
-
-    this->ForEachCertificate(certificate_ids, [&](auto& entry) {
-        *out_size += sizeof(BuiltInCertificateInfo);
-        *out_size += Common::AlignUp(static_cast<u32>(entry.second.der_data.size()), 4);
-        (*out_num_entries)++;
-    });
-
-    R_SUCCEED();
-}
-
-} // namespace Service::SSL

src/core/hle/service/ssl/cert_store.h

@@ -1,42 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <map>
-#include <span>
-#include <vector>
-
-#include "core/hle/result.h"
-#include "core/hle/service/ssl/ssl_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::SSL {
-
-class CertStore {
-public:
-    explicit CertStore(Core::System& system);
-    ~CertStore();
-
-    Result GetCertificates(u32* out_num_entries, std::span<u8> out_data,
-                           std::span<const CaCertificateId> certificate_ids);
-    Result GetCertificateBufSize(u32* out_size, u32* out_num_entries,
-                                 std::span<const CaCertificateId> certificate_ids);
-
-private:
-    template <typename F>
-    void ForEachCertificate(std::span<const CaCertificateId> certs, F&& f);
-
-private:
-    struct Certificate {
-        TrustedCertStatus status;
-        std::vector<u8> der_data;
-    };
-
-    std::map<CaCertificateId, Certificate> m_certs;
-};
-
-} // namespace Service::SSL

src/core/hle/service/ssl/ssl.cpp

@@ -5,13 +5,11 @@
 
 #include "core/core.h"
 #include "core/hle/result.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/sockets/bsd.h"
-#include "core/hle/service/ssl/cert_store.h"
 #include "core/hle/service/ssl/ssl.h"
 #include "core/hle/service/ssl/ssl_backend.h"
 #include "core/internal_network/network.h"
@@ -494,14 +492,13 @@ private:
 
 class ISslService final : public ServiceFramework<ISslService> {
 public:
-    explicit ISslService(Core::System& system_)
-        : ServiceFramework{system_, "ssl"}, cert_store{system} {
+    explicit ISslService(Core::System& system_) : ServiceFramework{system_, "ssl"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ISslService::CreateContext, "CreateContext"},
             {1, nullptr, "GetContextCount"},
-            {2, D<&ISslService::GetCertificates>, "GetCertificates"},
-            {3, D<&ISslService::GetCertificateBufSize>, "GetCertificateBufSize"},
+            {2, nullptr, "GetCertificates"},
+            {3, nullptr, "GetCertificateBufSize"},
             {4, nullptr, "DebugIoctl"},
             {5, &ISslService::SetInterfaceVersion, "SetInterfaceVersion"},
             {6, nullptr, "FlushSessionCache"},
@@ -543,22 +540,6 @@ private:
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
     }
-
-    Result GetCertificateBufSize(
-        Out<u32> out_size, InArray<CaCertificateId, BufferAttr_HipcMapAlias> certificate_ids) {
-        LOG_INFO(Service_SSL, "called");
-        u32 num_entries;
-        R_RETURN(cert_store.GetCertificateBufSize(out_size, &num_entries, certificate_ids));
-    }
-
-    Result GetCertificates(Out<u32> out_num_entries, OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                           InArray<CaCertificateId, BufferAttr_HipcMapAlias> certificate_ids) {
-        LOG_INFO(Service_SSL, "called");
-        R_RETURN(cert_store.GetCertificates(out_num_entries, out_buffer, certificate_ids));
-    }
-
-private:
-    CertStore cert_store;
 };
 
 void LoopProcess(Core::System& system) {

src/core/hle/service/ssl/ssl_types.h

@@ -1,107 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Service::SSL {
-
-enum class CaCertificateId : s32 {
-    All = -1,
-    NintendoCAG3 = 1,
-    NintendoClass2CAG3 = 2,
-    NintendoRootCAG4 = 3,
-    AmazonRootCA1 = 1000,
-    StarfieldServicesRootCertificateAuthorityG2 = 1001,
-    AddTrustExternalCARoot = 1002,
-    COMODOCertificationAuthority = 1003,
-    UTNDATACorpSGC = 1004,
-    UTNUSERFirstHardware = 1005,
-    BaltimoreCyberTrustRoot = 1006,
-    CybertrustGlobalRoot = 1007,
-    VerizonGlobalRootCA = 1008,
-    DigiCertAssuredIDRootCA = 1009,
-    DigiCertAssuredIDRootG2 = 1010,
-    DigiCertGlobalRootCA = 1011,
-    DigiCertGlobalRootG2 = 1012,
-    DigiCertHighAssuranceEVRootCA = 1013,
-    EntrustnetCertificationAuthority2048 = 1014,
-    EntrustRootCertificationAuthority = 1015,
-    EntrustRootCertificationAuthorityG2 = 1016,
-    GeoTrustGlobalCA2 = 1017,
-    GeoTrustGlobalCA = 1018,
-    GeoTrustPrimaryCertificationAuthorityG3 = 1019,
-    GeoTrustPrimaryCertificationAuthority = 1020,
-    GlobalSignRootCA = 1021,
-    GlobalSignRootCAR2 = 1022,
-    GlobalSignRootCAR3 = 1023,
-    GoDaddyClass2CertificationAuthority = 1024,
-    GoDaddyRootCertificateAuthorityG2 = 1025,
-    StarfieldClass2CertificationAuthority = 1026,
-    StarfieldRootCertificateAuthorityG2 = 1027,
-    thawtePrimaryRootCAG3 = 1028,
-    thawtePrimaryRootCA = 1029,
-    VeriSignClass3PublicPrimaryCertificationAuthorityG3 = 1030,
-    VeriSignClass3PublicPrimaryCertificationAuthorityG5 = 1031,
-    VeriSignUniversalRootCertificationAuthority = 1032,
-    DSTRootCAX3 = 1033,
-    USERTrustRsaCertificationAuthority = 1034,
-    ISRGRootX10 = 1035,
-    USERTrustEccCertificationAuthority = 1036,
-    COMODORsaCertificationAuthority = 1037,
-    COMODOEccCertificationAuthority = 1038,
-    AmazonRootCA2 = 1039,
-    AmazonRootCA3 = 1040,
-    AmazonRootCA4 = 1041,
-    DigiCertAssuredIDRootG3 = 1042,
-    DigiCertGlobalRootG3 = 1043,
-    DigiCertTrustedRootG4 = 1044,
-    EntrustRootCertificationAuthorityEC1 = 1045,
-    EntrustRootCertificationAuthorityG4 = 1046,
-    GlobalSignECCRootCAR4 = 1047,
-    GlobalSignECCRootCAR5 = 1048,
-    GlobalSignECCRootCAR6 = 1049,
-    GTSRootR1 = 1050,
-    GTSRootR2 = 1051,
-    GTSRootR3 = 1052,
-    GTSRootR4 = 1053,
-    SecurityCommunicationRootCA = 1054,
-    GlobalSignRootE4 = 1055,
-    GlobalSignRootR4 = 1056,
-    TTeleSecGlobalRootClass2 = 1057,
-    DigiCertTLSECCP384RootG5 = 1058,
-    DigiCertTLSRSA4096RootG5 = 1059,
-};
-
-enum class TrustedCertStatus : s32 {
-    Invalid = -1,
-    Removed = 0,
-    EnabledTrusted = 1,
-    EnabledNotTrusted = 2,
-    Revoked = 3,
-};
-
-struct BuiltInCertificateInfo {
-    CaCertificateId cert_id;
-    TrustedCertStatus status;
-    u64 der_size;
-    u64 der_offset;
-};
-static_assert(sizeof(BuiltInCertificateInfo) == 0x18, "BuiltInCertificateInfo has incorrect size.");
-
-struct CertStoreHeader {
-    u32 magic;
-    u32 num_entries;
-};
-static_assert(sizeof(CertStoreHeader) == 0x8, "CertStoreHeader has incorrect size.");
-
-struct CertStoreEntry {
-    CaCertificateId certificate_id;
-    TrustedCertStatus certificate_status;
-    u32 der_size;
-    u32 der_offset;
-};
-static_assert(sizeof(CertStoreEntry) == 0x10, "CertStoreEntry has incorrect size.");
-
-} // namespace Service::SSL

src/core/memory/cheat_engine.cpp

@@ -1,288 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <locale>
-#include "common/hex_util.h"
-#include "common/microprofile.h"
-#include "common/swap.h"
-#include "core/arm/debug.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/k_page_table.h"
-#include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_process_page_table.h"
-#include "core/hle/kernel/svc_types.h"
-#include "core/hle/service/hid/hid_server.h"
-#include "core/hle/service/sm/sm.h"
-#include "core/memory.h"
-#include "core/memory/cheat_engine.h"
-#include "hid_core/resource_manager.h"
-#include "hid_core/resources/npad/npad.h"
-
-namespace Core::Memory {
-namespace {
-constexpr auto CHEAT_ENGINE_NS = std::chrono::nanoseconds{1000000000 / 12};
-
-std::string_view ExtractName(std::size_t& out_name_size, std::string_view data,
-                             std::size_t start_index, char match) {
-    auto end_index = start_index;
-    while (data[end_index] != match) {
-        ++end_index;
-        if (end_index > data.size()) {
-            return {};
-        }
-    }
-
-    out_name_size = end_index - start_index;
-
-    // Clamp name if it's too big
-    if (out_name_size > sizeof(CheatDefinition::readable_name)) {
-        end_index = start_index + sizeof(CheatDefinition::readable_name);
-    }
-
-    return data.substr(start_index, end_index - start_index);
-}
-} // Anonymous namespace
-
-StandardVmCallbacks::StandardVmCallbacks(System& system_, const CheatProcessMetadata& metadata_)
-    : metadata{metadata_}, system{system_} {}
-
-StandardVmCallbacks::~StandardVmCallbacks() = default;
-
-void StandardVmCallbacks::MemoryReadUnsafe(VAddr address, void* data, u64 size) {
-    // Return zero on invalid address
-    if (!IsAddressInRange(address) || !system.ApplicationMemory().IsValidVirtualAddress(address)) {
-        std::memset(data, 0, size);
-        return;
-    }
-
-    system.ApplicationMemory().ReadBlock(address, data, size);
-}
-
-void StandardVmCallbacks::MemoryWriteUnsafe(VAddr address, const void* data, u64 size) {
-    // Skip invalid memory write address
-    if (!IsAddressInRange(address) || !system.ApplicationMemory().IsValidVirtualAddress(address)) {
-        return;
-    }
-
-    if (system.ApplicationMemory().WriteBlock(address, data, size)) {
-        Core::InvalidateInstructionCacheRange(system.ApplicationProcess(), address, size);
-    }
-}
-
-u64 StandardVmCallbacks::HidKeysDown() {
-    const auto hid = system.ServiceManager().GetService<Service::HID::IHidServer>("hid");
-    if (hid == nullptr) {
-        LOG_WARNING(CheatEngine, "Attempted to read input state, but hid is not initialized!");
-        return 0;
-    }
-
-    const auto applet_resource = hid->GetResourceManager();
-    if (applet_resource == nullptr || applet_resource->GetNpad() == nullptr) {
-        LOG_WARNING(CheatEngine,
-                    "Attempted to read input state, but applet resource is not initialized!");
-        return 0;
-    }
-
-    const auto press_state = applet_resource->GetNpad()->GetAndResetPressState();
-    return static_cast<u64>(press_state & HID::NpadButton::All);
-}
-
-void StandardVmCallbacks::PauseProcess() {
-    if (system.ApplicationProcess()->IsSuspended()) {
-        return;
-    }
-    system.ApplicationProcess()->SetActivity(Kernel::Svc::ProcessActivity::Paused);
-}
-
-void StandardVmCallbacks::ResumeProcess() {
-    if (!system.ApplicationProcess()->IsSuspended()) {
-        return;
-    }
-    system.ApplicationProcess()->SetActivity(Kernel::Svc::ProcessActivity::Runnable);
-}
-
-void StandardVmCallbacks::DebugLog(u8 id, u64 value) {
-    LOG_INFO(CheatEngine, "Cheat triggered DebugLog: ID '{:01X}' Value '{:016X}'", id, value);
-}
-
-void StandardVmCallbacks::CommandLog(std::string_view data) {
-    LOG_DEBUG(CheatEngine, "[DmntCheatVm]: {}",
-              data.back() == '\n' ? data.substr(0, data.size() - 1) : data);
-}
-
-bool StandardVmCallbacks::IsAddressInRange(VAddr in) const {
-    if ((in < metadata.main_nso_extents.base ||
-         in >= metadata.main_nso_extents.base + metadata.main_nso_extents.size) &&
-        (in < metadata.heap_extents.base ||
-         in >= metadata.heap_extents.base + metadata.heap_extents.size) &&
-        (in < metadata.alias_extents.base ||
-         in >= metadata.alias_extents.base + metadata.alias_extents.size) &&
-        (in < metadata.aslr_extents.base ||
-         in >= metadata.aslr_extents.base + metadata.aslr_extents.size)) {
-        LOG_DEBUG(CheatEngine,
-                  "Cheat attempting to access memory at invalid address={:016X}, if this "
-                  "persists, "
-                  "the cheat may be incorrect. However, this may be normal early in execution if "
-                  "the game has not properly set up yet.",
-                  in);
-        return false; ///< Invalid addresses will hard crash
-    }
-
-    return true;
-}
-
-CheatParser::~CheatParser() = default;
-
-TextCheatParser::~TextCheatParser() = default;
-
-std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
-    std::vector<CheatEntry> out(1);
-    std::optional<u64> current_entry;
-
-    for (std::size_t i = 0; i < data.size(); ++i) {
-        if (::isspace(data[i])) {
-            continue;
-        }
-
-        if (data[i] == '{') {
-            current_entry = 0;
-
-            if (out[*current_entry].definition.num_opcodes > 0) {
-                return {};
-            }
-
-            std::size_t name_size{};
-            const auto name = ExtractName(name_size, data, i + 1, '}');
-            if (name.empty()) {
-                return {};
-            }
-
-            std::memcpy(out[*current_entry].definition.readable_name.data(), name.data(),
-                        std::min<std::size_t>(out[*current_entry].definition.readable_name.size(),
-                                              name.size()));
-            out[*current_entry]
-                .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
-                '\0';
-
-            i += name_size + 1;
-        } else if (data[i] == '[') {
-            current_entry = out.size();
-            out.emplace_back();
-
-            std::size_t name_size{};
-            const auto name = ExtractName(name_size, data, i + 1, ']');
-            if (name.empty()) {
-                return {};
-            }
-
-            std::memcpy(out[*current_entry].definition.readable_name.data(), name.data(),
-                        std::min<std::size_t>(out[*current_entry].definition.readable_name.size(),
-                                              name.size()));
-            out[*current_entry]
-                .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
-                '\0';
-
-            i += name_size + 1;
-        } else if (::isxdigit(data[i])) {
-            if (!current_entry || out[*current_entry].definition.num_opcodes >=
-                                      out[*current_entry].definition.opcodes.size()) {
-                return {};
-            }
-
-            const auto hex = std::string(data.substr(i, 8));
-            if (!std::all_of(hex.begin(), hex.end(), ::isxdigit)) {
-                return {};
-            }
-
-            const auto value = static_cast<u32>(std::strtoul(hex.c_str(), nullptr, 0x10));
-            out[*current_entry].definition.opcodes[out[*current_entry].definition.num_opcodes++] =
-                value;
-
-            i += 8;
-        } else {
-            return {};
-        }
-    }
-
-    out[0].enabled = out[0].definition.num_opcodes > 0;
-    out[0].cheat_id = 0;
-
-    for (u32 i = 1; i < out.size(); ++i) {
-        out[i].enabled = out[i].definition.num_opcodes > 0;
-        out[i].cheat_id = i;
-    }
-
-    return out;
-}
-
-CheatEngine::CheatEngine(System& system_, std::vector<CheatEntry> cheats_,
-                         const std::array<u8, 0x20>& build_id_)
-    : vm{std::make_unique<StandardVmCallbacks>(system_, metadata)},
-      cheats(std::move(cheats_)), core_timing{system_.CoreTiming()}, system{system_} {
-    metadata.main_nso_build_id = build_id_;
-}
-
-CheatEngine::~CheatEngine() {
-    core_timing.UnscheduleEvent(event);
-}
-
-void CheatEngine::Initialize() {
-    event = Core::Timing::CreateEvent(
-        "CheatEngine::FrameCallback::" + Common::HexToString(metadata.main_nso_build_id),
-        [this](s64 time,
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            FrameCallback(ns_late);
-            return std::nullopt;
-        });
-    core_timing.ScheduleLoopingEvent(CHEAT_ENGINE_NS, CHEAT_ENGINE_NS, event);
-
-    metadata.process_id = system.ApplicationProcess()->GetProcessId();
-    metadata.title_id = system.GetApplicationProcessProgramID();
-
-    const auto& page_table = system.ApplicationProcess()->GetPageTable();
-    metadata.heap_extents = {
-        .base = GetInteger(page_table.GetHeapRegionStart()),
-        .size = page_table.GetHeapRegionSize(),
-    };
-    metadata.aslr_extents = {
-        .base = GetInteger(page_table.GetAliasCodeRegionStart()),
-        .size = page_table.GetAliasCodeRegionSize(),
-    };
-    metadata.alias_extents = {
-        .base = GetInteger(page_table.GetAliasRegionStart()),
-        .size = page_table.GetAliasRegionSize(),
-    };
-
-    is_pending_reload.exchange(true);
-}
-
-void CheatEngine::SetMainMemoryParameters(VAddr main_region_begin, u64 main_region_size) {
-    metadata.main_nso_extents = {
-        .base = main_region_begin,
-        .size = main_region_size,
-    };
-}
-
-void CheatEngine::Reload(std::vector<CheatEntry> reload_cheats) {
-    cheats = std::move(reload_cheats);
-    is_pending_reload.exchange(true);
-}
-
-MICROPROFILE_DEFINE(Cheat_Engine, "Add-Ons", "Cheat Engine", MP_RGB(70, 200, 70));
-
-void CheatEngine::FrameCallback(std::chrono::nanoseconds ns_late) {
-    if (is_pending_reload.exchange(false)) {
-        vm.LoadProgram(cheats);
-    }
-
-    if (vm.GetProgramSize() == 0) {
-        return;
-    }
-
-    MICROPROFILE_SCOPE(Cheat_Engine);
-
-    vm.Execute(metadata);
-}
-
-} // namespace Core::Memory

src/core/memory/cheat_engine.h

@@ -1,88 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <chrono>
-#include <memory>
-#include <vector>
-#include "common/common_types.h"
-#include "core/memory/dmnt_cheat_types.h"
-#include "core/memory/dmnt_cheat_vm.h"
-
-namespace Core {
-class System;
-}
-
-namespace Core::Timing {
-class CoreTiming;
-struct EventType;
-} // namespace Core::Timing
-
-namespace Core::Memory {
-
-class StandardVmCallbacks : public DmntCheatVm::Callbacks {
-public:
-    StandardVmCallbacks(System& system_, const CheatProcessMetadata& metadata_);
-    ~StandardVmCallbacks() override;
-
-    void MemoryReadUnsafe(VAddr address, void* data, u64 size) override;
-    void MemoryWriteUnsafe(VAddr address, const void* data, u64 size) override;
-    u64 HidKeysDown() override;
-    void PauseProcess() override;
-    void ResumeProcess() override;
-    void DebugLog(u8 id, u64 value) override;
-    void CommandLog(std::string_view data) override;
-
-private:
-    bool IsAddressInRange(VAddr address) const;
-
-    const CheatProcessMetadata& metadata;
-    Core::System& system;
-};
-
-// Intermediary class that parses a text file or other disk format for storing cheats into a
-// CheatList object, that can be used for execution.
-class CheatParser {
-public:
-    virtual ~CheatParser();
-
-    [[nodiscard]] virtual std::vector<CheatEntry> Parse(std::string_view data) const = 0;
-};
-
-// CheatParser implementation that parses text files
-class TextCheatParser final : public CheatParser {
-public:
-    ~TextCheatParser() override;
-
-    [[nodiscard]] std::vector<CheatEntry> Parse(std::string_view data) const override;
-};
-
-// Class that encapsulates a CheatList and manages its interaction with memory and CoreTiming
-class CheatEngine final {
-public:
-    CheatEngine(System& system_, std::vector<CheatEntry> cheats_,
-                const std::array<u8, 0x20>& build_id_);
-    ~CheatEngine();
-
-    void Initialize();
-    void SetMainMemoryParameters(VAddr main_region_begin, u64 main_region_size);
-
-    void Reload(std::vector<CheatEntry> reload_cheats);
-
-private:
-    void FrameCallback(std::chrono::nanoseconds ns_late);
-
-    DmntCheatVm vm;
-    CheatProcessMetadata metadata;
-
-    std::vector<CheatEntry> cheats;
-    std::atomic_bool is_pending_reload{false};
-
-    std::shared_ptr<Core::Timing::EventType> event;
-    Core::Timing::CoreTiming& core_timing;
-    Core::System& system;
-};
-
-} // namespace Core::Memory

src/core/memory/dmnt_cheat_types.h

@@ -1,37 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Core::Memory {
-
-struct MemoryRegionExtents {
-    u64 base{};
-    u64 size{};
-};
-
-struct CheatProcessMetadata {
-    u64 process_id{};
-    u64 title_id{};
-    MemoryRegionExtents main_nso_extents{};
-    MemoryRegionExtents heap_extents{};
-    MemoryRegionExtents alias_extents{};
-    MemoryRegionExtents aslr_extents{};
-    std::array<u8, 0x20> main_nso_build_id{};
-};
-
-struct CheatDefinition {
-    std::array<char, 0x40> readable_name{};
-    u32 num_opcodes{};
-    std::array<u32, 0x100> opcodes{};
-};
-
-struct CheatEntry {
-    bool enabled{};
-    u32 cheat_id{};
-    CheatDefinition definition{};
-};
-
-} // namespace Core::Memory

src/hid_core/frontend/emulated_controller.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
-#include <chrono>
 #include <common/scope_exit.h>
 
 #include "common/polyfill_ranges.h"
@@ -176,9 +175,10 @@ void EmulatedController::LoadDevices() {
     if (npad_id_type == NpadIdType::Player1 || npad_id_type == NpadIdType::Handheld) {
         camera_params[1] = Common::ParamPackage{"engine:camera,camera:1"};
         nfc_params[0] = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
-#ifndef ANDROID
+#ifdef HAVE_LIBUSB
         ring_params[1] = Common::ParamPackage{"engine:joycon,axis_x:100,axis_y:101"};
-#else
+#endif
+#ifdef ANDROID
         android_params = Common::ParamPackage{"engine:android,port:100"};
 #endif
     }
@@ -1287,22 +1287,6 @@ bool EmulatedController::SetVibration(DeviceIndex device_index, const VibrationV
         return false;
     }
 
-    if (!Settings::values.enable_accurate_vibrations.GetValue()) {
-        using std::chrono::duration_cast;
-        using std::chrono::milliseconds;
-        using std::chrono::steady_clock;
-
-        const auto now = steady_clock::now();
-
-        // Filter out non-zero vibrations that are within 15ms of each other.
-        if ((vibration.low_amplitude != 0.0f || vibration.high_amplitude != 0.0f) &&
-            duration_cast<milliseconds>(now - last_vibration_timepoint[index]) < milliseconds(15)) {
-            return false;
-        }
-
-        last_vibration_timepoint[index] = now;
-    }
-
     // Exponential amplification is too strong at low amplitudes. Switch to a linear
     // amplification if strength is set below 0.7f
     const Common::Input::VibrationAmplificationType type =

src/hid_core/frontend/emulated_controller.h

@@ -583,7 +583,6 @@ private:
     std::size_t nfc_handles{0};
     std::array<VibrationValue, 2> last_vibration_value{DEFAULT_VIBRATION_VALUE,
                                                        DEFAULT_VIBRATION_VALUE};
-    std::array<std::chrono::steady_clock::time_point, 2> last_vibration_timepoint{};
 
     // Temporary values to avoid doing changes while the controller is in configuring mode
     NpadStyleIndex tmp_npad_type{NpadStyleIndex::None};

src/hid_core/hid_types.h

@@ -565,28 +565,36 @@ static_assert(sizeof(SixAxisSensorProperties) == 1, "SixAxisSensorProperties is
 
 // This is nn::hid::SixAxisSensorCalibrationParameter
 struct SixAxisSensorCalibrationParameter {
-    std::array<u8, 0x744> unknown_data;
+    std::array<u8, 0x744> unknown_data{};
 };
 static_assert(sizeof(SixAxisSensorCalibrationParameter) == 0x744,
               "SixAxisSensorCalibrationParameter is an invalid size");
-static_assert(std::is_trivial_v<SixAxisSensorCalibrationParameter>,
-              "SixAxisSensorCalibrationParameter must be trivial.");
 
 // This is nn::hid::SixAxisSensorIcInformation
 struct SixAxisSensorIcInformation {
-    f32 angular_rate;                      // dps
-    std::array<f32, 6> unknown_gyro_data1; // dps
-    std::array<f32, 9> unknown_gyro_data2;
-    std::array<f32, 9> unknown_gyro_data3;
-    f32 acceleration_range;                 // g force
-    std::array<f32, 6> unknown_accel_data1; // g force
-    std::array<f32, 9> unknown_accel_data2;
-    std::array<f32, 9> unknown_accel_data3;
+    f32 angular_rate{2000.0f}; // dps
+    std::array<f32, 6> unknown_gyro_data1{
+        -10.0f, -10.0f, -10.0f, 10.0f, 10.0f, 10.0f,
+    }; // dps
+    std::array<f32, 9> unknown_gyro_data2{
+        0.95f, -0.003f, -0.003f, -0.003f, 0.95f, -0.003f, -0.003f, -0.003f, 0.95f,
+    };
+    std::array<f32, 9> unknown_gyro_data3{
+        1.05f, 0.003f, 0.003f, 0.003f, 1.05f, 0.003f, 0.003f, 0.003f, 1.05f,
+    };
+    f32 acceleration_range{8.0f}; // g force
+    std::array<f32, 6> unknown_accel_data1{
+        -0.0612f, -0.0612f, -0.0612f, 0.0612f, 0.0612f, 0.0612f,
+    }; // g force
+    std::array<f32, 9> unknown_accel_data2{
+        0.95f, -0.003f, -0.003f, -0.003f, 0.95f, -0.003f, -0.003f, -0.003f, 0.95f,
+    };
+    std::array<f32, 9> unknown_accel_data3{
+        1.05f, 0.003f, 0.003f, 0.003f, 1.05f, 0.003f, 0.003f, 0.003f, 1.05f,
+    };
 };
 static_assert(sizeof(SixAxisSensorIcInformation) == 0xC8,
               "SixAxisSensorIcInformation is an invalid size");
-static_assert(std::is_trivial_v<SixAxisSensorIcInformation>,
-              "SixAxisSensorIcInformation must be trivial.");
 
 // This is nn::hid::SixAxisSensorAttribute
 struct SixAxisSensorAttribute {
@@ -630,11 +638,7 @@ struct VibrationValue {
         if (low_amplitude != b.low_amplitude || high_amplitude != b.high_amplitude) {
             return false;
         }
-        // Changes in frequency without amplitude don't have any effect
-        if (low_amplitude == 0 && high_amplitude == 0) {
-            return true;
-        }
-        if (low_frequency != b.low_frequency || high_frequency != b.high_frequency) {
+        if (low_frequency != b.low_amplitude || high_frequency != b.high_frequency) {
             return false;
         }
         return true;

src/hid_core/resource_manager.cpp

@@ -4,6 +4,7 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/set/system_settings_server.h"
 #include "core/hle/service/sm/sm.h"
@@ -500,4 +501,29 @@ void ResourceManager::UpdateMotion(std::chrono::nanoseconds ns_late) {
     console_six_axis->OnUpdate(core_timing);
 }
 
+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);
+}
+
+IAppletResource::~IAppletResource() {
+    resource_manager->FreeAppletResourceId(aruid);
+}
+
+void IAppletResource::GetSharedMemoryHandle(HLERequestContext& ctx) {
+    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(result);
+    rb.PushCopyObjects(handle);
+}
+
 } // namespace Service::HID

src/hid_core/resource_manager.h

@@ -174,4 +174,17 @@ private:
     KernelHelpers::ServiceContext service_context;
 };
 
+class IAppletResource final : public ServiceFramework<IAppletResource> {
+public:
+    explicit IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource,
+                             u64 applet_resource_user_id);
+    ~IAppletResource() override;
+
+private:
+    void GetSharedMemoryHandle(HLERequestContext& ctx);
+
+    u64 aruid{};
+    std::shared_ptr<ResourceManager> resource_manager;
+};
+
 } // namespace Service::HID

src/hid_core/resources/npad/npad.cpp

@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <array>
+#include <chrono>
 #include <cstring>
 
 #include "common/assert.h"

src/hid_core/resources/palma/palma.cpp

@@ -56,14 +56,12 @@ Kernel::KReadableEvent& Palma::AcquirePalmaOperationCompleteEvent(
 
 Result Palma::GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
                                     PalmaOperationType& operation_type,
-                                    std::span<u8> out_data) const {
+                                    PalmaOperationData& data) const {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation_type = static_cast<PalmaOperationType>(operation.operation);
-    std::memcpy(out_data.data(), operation.data.data(),
-                std::min(out_data.size(), operation.data.size()));
-
+    operation_type = operation.operation;
+    data = operation.data;
     return ResultSuccess;
 }
 
@@ -71,7 +69,7 @@ Result Palma::PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_a
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PackedPalmaOperationType::PlayActivity;
+    operation.operation = PalmaOperationType::PlayActivity;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -90,7 +88,7 @@ Result Palma::ReadPalmaStep(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PackedPalmaOperationType::ReadStep;
+    operation.operation = PalmaOperationType::ReadStep;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -119,7 +117,7 @@ Result Palma::ReadPalmaUniqueCode(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PackedPalmaOperationType::ReadUniqueCode;
+    operation.operation = PalmaOperationType::ReadUniqueCode;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -130,7 +128,7 @@ Result Palma::SetPalmaUniqueCodeInvalid(const PalmaConnectionHandle& handle) {
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PackedPalmaOperationType::SetUniqueCodeInvalid;
+    operation.operation = PalmaOperationType::SetUniqueCodeInvalid;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -143,7 +141,7 @@ Result Palma::WritePalmaRgbLedPatternEntry(const PalmaConnectionHandle& handle,
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PackedPalmaOperationType::WriteRgbLedPatternEntry;
+    operation.operation = PalmaOperationType::WriteRgbLedPatternEntry;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -155,7 +153,7 @@ Result Palma::WritePalmaWaveEntry(const PalmaConnectionHandle& handle, PalmaWave
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PackedPalmaOperationType::WriteWaveEntry;
+    operation.operation = PalmaOperationType::WriteWaveEntry;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation_complete_event->Signal();
@@ -168,7 +166,7 @@ Result Palma::SetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle&
         return InvalidPalmaHandle;
     }
     database_id_version = database_id_version_;
-    operation.operation = PackedPalmaOperationType::ReadDataBaseIdentificationVersion;
+    operation.operation = PalmaOperationType::ReadDataBaseIdentificationVersion;
     operation.result = PalmaResultSuccess;
     operation.data[0] = {};
     operation_complete_event->Signal();
@@ -179,7 +177,7 @@ Result Palma::GetPalmaDataBaseIdentificationVersion(const PalmaConnectionHandle&
     if (handle.npad_id != active_handle.npad_id) {
         return InvalidPalmaHandle;
     }
-    operation.operation = PackedPalmaOperationType::ReadDataBaseIdentificationVersion;
+    operation.operation = PalmaOperationType::ReadDataBaseIdentificationVersion;
     operation.result = PalmaResultSuccess;
     operation.data = {};
     operation.data[0] = static_cast<u8>(database_id_version);

src/hid_core/resources/palma/palma.h

@@ -4,8 +4,6 @@
 #pragma once
 
 #include <array>
-#include <span>
-
 #include "common/common_funcs.h"
 #include "common/typed_address.h"
 #include "hid_core/hid_result.h"
@@ -29,31 +27,9 @@ namespace Service::HID {
 class Palma final : public ControllerBase {
 public:
     using PalmaOperationData = std::array<u8, 0x140>;
-    using PalmaApplicationSection = std::array<u8, 0x100>;
-    using Address = std::array<u8, 0x6>;
 
     // This is nn::hid::PalmaOperationType
-    enum class PalmaOperationType : u64 {
-        PlayActivity,
-        SetFrModeType,
-        ReadStep,
-        EnableStep,
-        ResetStep,
-        ReadApplicationSection,
-        WriteApplicationSection,
-        ReadUniqueCode,
-        SetUniqueCodeInvalid,
-        WriteActivityEntry,
-        WriteRgbLedPatternEntry,
-        WriteWaveEntry,
-        ReadDataBaseIdentificationVersion,
-        WriteDataBaseIdentificationVersion,
-        SuspendFeature,
-        ReadPlayLog,
-        ResetPlayLog,
-    };
-
-    enum class PackedPalmaOperationType : u32 {
+    enum class PalmaOperationType {
         PlayActivity,
         SetFrModeType,
         ReadStep,
@@ -99,7 +75,7 @@ public:
 
     // This is nn::hid::PalmaOperationInfo
     struct PalmaOperationInfo {
-        PackedPalmaOperationType operation{};
+        PalmaOperationType operation{};
         Result result{PalmaResultSuccess};
         PalmaOperationData data{};
     };
@@ -116,7 +92,8 @@ public:
     static_assert(sizeof(PalmaActivityEntry) == 0x20, "PalmaActivityEntry is an invalid size");
 
     struct PalmaConnectionHandle {
-        alignas(8) Core::HID::NpadIdType npad_id;
+        Core::HID::NpadIdType npad_id;
+        INSERT_PADDING_BYTES(4); // Unknown
     };
     static_assert(sizeof(PalmaConnectionHandle) == 0x8,
                   "PalmaConnectionHandle has incorrect size.");
@@ -138,7 +115,8 @@ public:
     Kernel::KReadableEvent& AcquirePalmaOperationCompleteEvent(
         const PalmaConnectionHandle& handle) const;
     Result GetPalmaOperationInfo(const PalmaConnectionHandle& handle,
-                                 PalmaOperationType& operation_type, std::span<u8> out_data) const;
+                                 PalmaOperationType& operation_type,
+                                 PalmaOperationData& data) const;
     Result PlayPalmaActivity(const PalmaConnectionHandle& handle, u64 palma_activity);
     Result SetPalmaFrModeType(const PalmaConnectionHandle& handle, PalmaFrModeType fr_mode_);
     Result ReadPalmaStep(const PalmaConnectionHandle& handle);

src/video_core/buffer_cache/buffer_cache.h

@@ -1488,10 +1488,7 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
             std::span<const u8> upload_span;
             const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
             if (IsRangeGranular(device_addr, copy.size)) {
-                auto* const ptr = device_memory.GetPointer<u8>(device_addr);
-                if (ptr != nullptr) {
-                    upload_span = std::span(ptr, copy.size);
-                }
+                upload_span = std::span(device_memory.GetPointer<u8>(device_addr), copy.size);
             } else {
                 if (immediate_buffer.empty()) {
                     immediate_buffer = ImmediateBuffer(largest_copy);

src/video_core/buffer_cache/usage_tracker.h

@@ -26,9 +26,6 @@ public:
     void Track(u64 offset, u64 size) noexcept {
         const size_t page = offset >> PAGE_SHIFT;
         const size_t page_end = (offset + size) >> PAGE_SHIFT;
-        if (page_end < page || page_end >= pages.size()) {
-            return;
-        }
         TrackPage(page, offset, size);
         if (page == page_end) {
             return;
@@ -44,9 +41,6 @@ public:
     [[nodiscard]] bool IsUsed(u64 offset, u64 size) const noexcept {
         const size_t page = offset >> PAGE_SHIFT;
         const size_t page_end = (offset + size) >> PAGE_SHIFT;
-        if (page_end < page || page_end >= pages.size()) {
-            return false;
-        }
         if (IsPageUsed(page, offset, size)) {
             return true;
         }

src/video_core/control/channel_state.cpp

@@ -16,9 +16,8 @@ namespace Tegra::Control {
 
 ChannelState::ChannelState(s32 bind_id_) : bind_id{bind_id_}, initialized{} {}
 
-void ChannelState::Init(Core::System& system, GPU& gpu, u64 program_id_) {
+void ChannelState::Init(Core::System& system, GPU& gpu) {
     ASSERT(memory_manager);
-    program_id = program_id_;
     dma_pusher = std::make_unique<Tegra::DmaPusher>(system, gpu, *memory_manager, *this);
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, *memory_manager);
     fermi_2d = std::make_unique<Engines::Fermi2D>(*memory_manager);

src/video_core/control/channel_state.h

@@ -40,12 +40,11 @@ struct ChannelState {
     ChannelState(ChannelState&& other) noexcept = default;
     ChannelState& operator=(ChannelState&& other) noexcept = default;
 
-    void Init(Core::System& system, GPU& gpu, u64 program_id);
+    void Init(Core::System& system, GPU& gpu);
 
     void BindRasterizer(VideoCore::RasterizerInterface* rasterizer);
 
     s32 bind_id = -1;
-    u64 program_id = 0;
     /// 3D engine
     std::unique_ptr<Engines::Maxwell3D> maxwell_3d;
     /// 2D engine

src/video_core/control/channel_state_cache.cpp

@@ -7,7 +7,7 @@ namespace VideoCommon {
 
 ChannelInfo::ChannelInfo(Tegra::Control::ChannelState& channel_state)
     : maxwell3d{*channel_state.maxwell_3d}, kepler_compute{*channel_state.kepler_compute},
-      gpu_memory{*channel_state.memory_manager}, program_id{channel_state.program_id} {}
+      gpu_memory{*channel_state.memory_manager} {}
 
 template class VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo>;
 

src/video_core/control/channel_state_cache.h

@@ -39,7 +39,6 @@ public:
     Tegra::Engines::Maxwell3D& maxwell3d;
     Tegra::Engines::KeplerCompute& kepler_compute;
     Tegra::MemoryManager& gpu_memory;
-    u64 program_id;
 };
 
 template <class P>
@@ -78,10 +77,9 @@ protected:
     P* channel_state;
     size_t current_channel_id{UNSET_CHANNEL};
     size_t current_address_space{};
-    Tegra::Engines::Maxwell3D* maxwell3d{};
-    Tegra::Engines::KeplerCompute* kepler_compute{};
-    Tegra::MemoryManager* gpu_memory{};
-    u64 program_id{};
+    Tegra::Engines::Maxwell3D* maxwell3d;
+    Tegra::Engines::KeplerCompute* kepler_compute;
+    Tegra::MemoryManager* gpu_memory;
 
     std::deque<P> channel_storage;
     std::deque<size_t> free_channel_ids;

src/video_core/control/channel_state_cache.inc

@@ -58,7 +58,6 @@ void ChannelSetupCaches<P>::BindToChannel(s32 id) {
     maxwell3d = &channel_state->maxwell3d;
     kepler_compute = &channel_state->kepler_compute;
     gpu_memory = &channel_state->gpu_memory;
-    program_id = channel_state->program_id;
     current_address_space = gpu_memory->GetID();
 }
 
@@ -77,7 +76,6 @@ void ChannelSetupCaches<P>::EraseChannel(s32 id) {
         maxwell3d = nullptr;
         kepler_compute = nullptr;
         gpu_memory = nullptr;
-        program_id = 0;
     } else if (current_channel_id != UNSET_CHANNEL) {
         channel_state = &channel_storage[current_channel_id];
     }

src/video_core/engines/draw_manager.cpp

@@ -216,11 +216,14 @@ void DrawManager::DrawTexture() {
     const bool lower_left{regs.window_origin.mode !=
                           Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
     if (lower_left) {
-        draw_texture_state.dst_y0 =
-            static_cast<f32>(regs.surface_clip.height) - draw_texture_state.dst_y0;
+        draw_texture_state.dst_y0 -= dst_height;
     }
-    draw_texture_state.dst_x1 = draw_texture_state.dst_x0 + dst_width;
-    draw_texture_state.dst_y1 = draw_texture_state.dst_y0 + dst_height;
+    draw_texture_state.dst_x1 =
+        draw_texture_state.dst_x0 +
+        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(dst_width)));
+    draw_texture_state.dst_y1 =
+        draw_texture_state.dst_y0 +
+        static_cast<f32>(Settings::values.resolution_info.ScaleUp(static_cast<u32>(dst_height)));
     draw_texture_state.src_x0 = static_cast<float>(regs.draw_texture.src_x0) / 4096.f;
     draw_texture_state.src_y0 = static_cast<float>(regs.draw_texture.src_y0) / 4096.f;
     draw_texture_state.src_x1 =

src/video_core/gpu.cpp

@@ -67,8 +67,8 @@ struct GPU::Impl {
         return CreateChannel(new_channel_id++);
     }
 
-    void InitChannel(Control::ChannelState& to_init, u64 program_id) {
-        to_init.Init(system, gpu, program_id);
+    void InitChannel(Control::ChannelState& to_init) {
+        to_init.Init(system, gpu);
         to_init.BindRasterizer(rasterizer);
         rasterizer->InitializeChannel(to_init);
     }
@@ -412,8 +412,8 @@ std::shared_ptr<Control::ChannelState> GPU::AllocateChannel() {
     return impl->AllocateChannel();
 }
 
-void GPU::InitChannel(Control::ChannelState& to_init, u64 program_id) {
-    impl->InitChannel(to_init, program_id);
+void GPU::InitChannel(Control::ChannelState& to_init) {
+    impl->InitChannel(to_init);
 }
 
 void GPU::BindChannel(s32 channel_id) {

src/video_core/gpu.h

@@ -149,7 +149,7 @@ public:
 
     std::shared_ptr<Control::ChannelState> AllocateChannel();
 
-    void InitChannel(Control::ChannelState& to_init, u64 program_id);
+    void InitChannel(Control::ChannelState& to_init);
 
     void BindChannel(s32 channel_id);
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -370,32 +370,27 @@ void RasterizerOpenGL::DrawTexture() {
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
 
-    const auto Scale = [&](auto dim) -> s32 {
-        return Settings::values.resolution_info.ScaleUp(static_cast<s32>(dim));
-    };
-
-    Region2D dst_region = {
-        Offset2D{.x = Scale(draw_texture_state.dst_x0), .y = Scale(draw_texture_state.dst_y0)},
-        Offset2D{.x = Scale(draw_texture_state.dst_x1), .y = Scale(draw_texture_state.dst_y1)}};
-    Region2D src_region = {
-        Offset2D{.x = Scale(draw_texture_state.src_x0), .y = Scale(draw_texture_state.src_y0)},
-        Offset2D{.x = Scale(draw_texture_state.src_x1), .y = Scale(draw_texture_state.src_y1)}};
-    Extent3D src_size = {static_cast<u32>(Scale(texture.size.width)),
-                         static_cast<u32>(Scale(texture.size.height)), texture.size.depth};
-
     if (device.HasDrawTexture()) {
         state_tracker.BindFramebuffer(texture_cache.GetFramebuffer()->Handle());
 
-        glDrawTextureNV(texture.DefaultHandle(), sampler->Handle(),
-                        static_cast<f32>(dst_region.start.x), static_cast<f32>(dst_region.start.y),
-                        static_cast<f32>(dst_region.end.x), static_cast<f32>(dst_region.end.y), 0,
+        glDrawTextureNV(texture.DefaultHandle(), sampler->Handle(), draw_texture_state.dst_x0,
+                        draw_texture_state.dst_y0, draw_texture_state.dst_x1,
+                        draw_texture_state.dst_y1, 0,
                         draw_texture_state.src_x0 / static_cast<float>(texture.size.width),
                         draw_texture_state.src_y0 / static_cast<float>(texture.size.height),
                         draw_texture_state.src_x1 / static_cast<float>(texture.size.width),
                         draw_texture_state.src_y1 / static_cast<float>(texture.size.height));
     } else {
+        Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
+                                        .y = static_cast<s32>(draw_texture_state.dst_y0)},
+                               Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
+                                        .y = static_cast<s32>(draw_texture_state.dst_y1)}};
+        Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
+                                        .y = static_cast<s32>(draw_texture_state.src_y0)},
+                               Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
+                                        .y = static_cast<s32>(draw_texture_state.src_y1)}};
         blit_image.BlitColor(texture_cache.GetFramebuffer()->Handle(), texture.DefaultHandle(),
-                             sampler->Handle(), dst_region, src_region, src_size);
+                             sampler->Handle(), dst_region, src_region, texture.size);
         state_tracker.InvalidateState();
     }
 

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -215,7 +215,6 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
           .support_gl_variable_aoffi = device.HasVariableAoffi(),
           .support_gl_sparse_textures = device.HasSparseTexture2(),
           .support_gl_derivative_control = device.HasDerivativeControl(),
-          .support_geometry_streams = true,
 
           .warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyLargerThanGuest(),
 

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1064,6 +1064,8 @@ public:
                 }
             });
         }
+        auto* ptr = device_memory.GetPointer<u8>(new_query->dependant_address);
+        ASSERT(ptr != nullptr);
 
         new_query->dependant_manage = must_manage_dependance;
         pending_flush_queries.push_back(index);
@@ -1102,11 +1104,9 @@ public:
                 tfb_streamer.Free(query->dependant_index);
             } else {
                 u8* pointer = device_memory.GetPointer<u8>(query->dependant_address);
-                if (pointer != nullptr) {
-                    u32 result;
-                    std::memcpy(&result, pointer, sizeof(u32));
-                    num_vertices = static_cast<u64>(result) / query->stride;
-                }
+                u32 result;
+                std::memcpy(&result, pointer, sizeof(u32));
+                num_vertices = static_cast<u64>(result) / query->stride;
             }
             query->value = [&]() -> u64 {
                 switch (query->topology) {
@@ -1360,9 +1360,7 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValues(VideoCommon::Looku
     const auto check_value = [&](DAddr address) {
         u8* ptr = impl->device_memory.GetPointer<u8>(address);
         u64 value{};
-        if (ptr != nullptr) {
-            std::memcpy(&value, ptr, sizeof(value));
-        }
+        std::memcpy(&value, ptr, sizeof(value));
         return value == 0;
     };
     std::array<VideoCommon::LookupData*, 2> objects{&object_1, &object_2};

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -125,23 +125,11 @@ VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u3
         return value < 0 ? std::min<s32>(converted_value - acumm, -1)
                          : std::max<s32>(converted_value + acumm, 1);
     };
-
-    const bool lower_left = regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft;
-    const s32 clip_height = regs.surface_clip.height;
-
-    // Flip coordinates if lower left
-    s32 min_y = lower_left ? (clip_height - src.max_y) : src.min_y.Value();
-    s32 max_y = lower_left ? (clip_height - src.min_y) : src.max_y.Value();
-
-    // Bound to render area
-    min_y = std::max(min_y, 0);
-    max_y = std::max(max_y, 0);
-
     if (src.enable) {
-        scissor.offset.x = scale_up(src.min_x);
-        scissor.offset.y = scale_up(min_y);
+        scissor.offset.x = scale_up(static_cast<s32>(src.min_x));
+        scissor.offset.y = scale_up(static_cast<s32>(src.min_y));
         scissor.extent.width = scale_up(src.max_x - src.min_x);
-        scissor.extent.height = scale_up(max_y - min_y);
+        scissor.extent.height = scale_up(src.max_y - src.min_y);
     } else {
         scissor.offset.x = 0;
         scissor.offset.y = 0;
@@ -320,33 +308,17 @@ void RasterizerVulkan::DrawTexture() {
     const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
-    const auto* framebuffer = texture_cache.GetFramebuffer();
-
-    const bool src_rescaling = texture_cache.IsRescaling() && texture.IsRescaled();
-    const bool dst_rescaling = texture_cache.IsRescaling() && framebuffer->IsRescaled();
-
-    const auto ScaleSrc = [&](auto dim_f) -> s32 {
-        auto dim = static_cast<s32>(dim_f);
-        return src_rescaling ? Settings::values.resolution_info.ScaleUp(dim) : dim;
-    };
-
-    const auto ScaleDst = [&](auto dim_f) -> s32 {
-        auto dim = static_cast<s32>(dim_f);
-        return dst_rescaling ? Settings::values.resolution_info.ScaleUp(dim) : dim;
-    };
-
-    Region2D dst_region = {Offset2D{.x = ScaleDst(draw_texture_state.dst_x0),
-                                    .y = ScaleDst(draw_texture_state.dst_y0)},
-                           Offset2D{.x = ScaleDst(draw_texture_state.dst_x1),
-                                    .y = ScaleDst(draw_texture_state.dst_y1)}};
-    Region2D src_region = {Offset2D{.x = ScaleSrc(draw_texture_state.src_x0),
-                                    .y = ScaleSrc(draw_texture_state.src_y0)},
-                           Offset2D{.x = ScaleSrc(draw_texture_state.src_x1),
-                                    .y = ScaleSrc(draw_texture_state.src_y1)}};
-    Extent3D src_size = {static_cast<u32>(ScaleSrc(texture.size.width)),
-                         static_cast<u32>(ScaleSrc(texture.size.height)), texture.size.depth};
-    blit_image.BlitColor(framebuffer, texture.RenderTarget(), texture.ImageHandle(),
-                         sampler->Handle(), dst_region, src_region, src_size);
+    Region2D dst_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x0),
+                                    .y = static_cast<s32>(draw_texture_state.dst_y0)},
+                           Offset2D{.x = static_cast<s32>(draw_texture_state.dst_x1),
+                                    .y = static_cast<s32>(draw_texture_state.dst_y1)}};
+    Region2D src_region = {Offset2D{.x = static_cast<s32>(draw_texture_state.src_x0),
+                                    .y = static_cast<s32>(draw_texture_state.src_y0)},
+                           Offset2D{.x = static_cast<s32>(draw_texture_state.src_x1),
+                                    .y = static_cast<s32>(draw_texture_state.src_y1)}};
+    blit_image.BlitColor(texture_cache.GetFramebuffer(), texture.RenderTarget(),
+                         texture.ImageHandle(), sampler->Handle(), dst_region, src_region,
+                         texture.size);
 }
 
 void RasterizerVulkan::Clear(u32 layer_count) {
@@ -1082,16 +1054,37 @@ void RasterizerVulkan::UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs) {
                         regs.zeta.format == Tegra::DepthFormat::X8Z24_UNORM ||
                         regs.zeta.format == Tegra::DepthFormat::S8Z24_UNORM ||
                         regs.zeta.format == Tegra::DepthFormat::V8Z24_UNORM;
-    if (is_d24 && !device.SupportsD24DepthBuffer() && program_id == 0x1006A800016E000ULL) {
-        // Only activate this in Super Smash Brothers Ultimate
+    bool force_unorm = ([&] {
+        if (!is_d24 || device.SupportsD24DepthBuffer()) {
+            return false;
+        }
+        if (device.IsExtDepthBiasControlSupported()) {
+            return true;
+        }
+        if (!Settings::values.renderer_amdvlk_depth_bias_workaround) {
+            return false;
+        }
         // the base formulas can be obtained from here:
         //   https://docs.microsoft.com/en-us/windows/win32/direct3d11/d3d10-graphics-programming-guide-output-merger-stage-depth-bias
         const double rescale_factor =
             static_cast<double>(1ULL << (32 - 24)) / (static_cast<double>(0x1.ep+127));
         units = static_cast<float>(static_cast<double>(units) * rescale_factor);
-    }
+        return false;
+    })();
     scheduler.Record([constant = units, clamp = regs.depth_bias_clamp,
-                      factor = regs.slope_scale_depth_bias](vk::CommandBuffer cmdbuf) {
+                      factor = regs.slope_scale_depth_bias, force_unorm,
+                      precise = device.HasExactDepthBiasControl()](vk::CommandBuffer cmdbuf) {
+        if (force_unorm) {
+            VkDepthBiasRepresentationInfoEXT info{
+                .sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT,
+                .pNext = nullptr,
+                .depthBiasRepresentation =
+                    VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT,
+                .depthBiasExact = precise ? VK_TRUE : VK_FALSE,
+            };
+            cmdbuf.SetDepthBias(constant, clamp, factor, &info);
+            return;
+        }
         cmdbuf.SetDepthBias(constant, clamp, factor);
     });
 }

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1962,22 +1962,21 @@ Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM
 }
 
 Framebuffer::Framebuffer(TextureCacheRuntime& runtime, ImageView* color_buffer,
-                         ImageView* depth_buffer, VkExtent2D extent, bool is_rescaled_)
+                         ImageView* depth_buffer, VkExtent2D extent, bool is_rescaled)
     : render_area{extent} {
     std::array<ImageView*, NUM_RT> color_buffers{color_buffer};
-    CreateFramebuffer(runtime, color_buffers, depth_buffer, is_rescaled_);
+    CreateFramebuffer(runtime, color_buffers, depth_buffer, is_rescaled);
 }
 
 Framebuffer::~Framebuffer() = default;
 
 void Framebuffer::CreateFramebuffer(TextureCacheRuntime& runtime,
                                     std::span<ImageView*, NUM_RT> color_buffers,
-                                    ImageView* depth_buffer, bool is_rescaled_) {
+                                    ImageView* depth_buffer, bool is_rescaled) {
     boost::container::small_vector<VkImageView, NUM_RT + 1> attachments;
     RenderPassKey renderpass_key{};
     s32 num_layers = 1;
 
-    is_rescaled = is_rescaled_;
     const auto& resolution = runtime.resolution;
 
     u32 width = std::numeric_limits<u32>::max();

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -361,10 +361,6 @@ public:
         return has_stencil;
     }
 
-    [[nodiscard]] bool IsRescaled() const noexcept {
-        return is_rescaled;
-    }
-
 private:
     vk::Framebuffer framebuffer;
     VkRenderPass renderpass{};
@@ -377,7 +373,6 @@ private:
     std::array<size_t, NUM_RT> rt_map{};
     bool has_depth{};
     bool has_stencil{};
-    bool is_rescaled{};
 };
 
 struct TextureCacheParams {

src/video_core/texture_cache/texture_cache.h

@@ -72,19 +72,12 @@ TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManag
 
 template <class P>
 void TextureCache<P>::RunGarbageCollector() {
-    bool high_priority_mode = false;
-    bool aggressive_mode = false;
-    u64 ticks_to_destroy = 0;
-    size_t num_iterations = 0;
-
-    const auto Configure = [&](bool allow_aggressive) {
-        high_priority_mode = total_used_memory >= expected_memory;
-        aggressive_mode = allow_aggressive && total_used_memory >= critical_memory;
-        ticks_to_destroy = aggressive_mode ? 10ULL : high_priority_mode ? 25ULL : 50ULL;
-        num_iterations = aggressive_mode ? 40 : (high_priority_mode ? 20 : 10);
-    };
-    const auto Cleanup = [this, &num_iterations, &high_priority_mode,
-                          &aggressive_mode](ImageId image_id) {
+    bool high_priority_mode = total_used_memory >= expected_memory;
+    bool aggressive_mode = total_used_memory >= critical_memory;
+    const u64 ticks_to_destroy = aggressive_mode ? 10ULL : high_priority_mode ? 25ULL : 50ULL;
+    size_t num_iterations = aggressive_mode ? 40 : (high_priority_mode ? 20 : 10);
+    const auto clean_up = [this, &num_iterations, &high_priority_mode,
+                           &aggressive_mode](ImageId image_id) {
         if (num_iterations == 0) {
             return true;
         }
@@ -130,16 +123,7 @@ void TextureCache<P>::RunGarbageCollector() {
         }
         return false;
     };
-
-    // Try to remove anything old enough and not high priority.
-    Configure(false);
-    lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
-
-    // If pressure is still too high, prune aggressively.
-    if (total_used_memory >= critical_memory) {
-        Configure(true);
-        lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, Cleanup);
-    }
+    lru_cache.ForEachItemBelow(frame_tick - ticks_to_destroy, clean_up);
 }
 
 template <class P>
@@ -2114,9 +2098,7 @@ void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(False(image.flags & ImageFlagBits::Tracked));
     image.flags |= ImageFlagBits::Tracked;
     if (False(image.flags & ImageFlagBits::Sparse)) {
-        if (image.cpu_addr < ~(1ULL << 40)) {
-            device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
-        }
+        device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
         return;
     }
     if (True(image.flags & ImageFlagBits::Registered)) {
@@ -2142,9 +2124,7 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
     ASSERT(True(image.flags & ImageFlagBits::Tracked));
     image.flags &= ~ImageFlagBits::Tracked;
     if (False(image.flags & ImageFlagBits::Sparse)) {
-        if (image.cpu_addr < ~(1ULL << 40)) {
-            device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
-        }
+        device_memory.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
         return;
     }
     ASSERT(True(image.flags & ImageFlagBits::Registered));

src/yuzu/configuration/configure_applets.cpp

@@ -59,7 +59,9 @@ void ConfigureApplets::Setup(const ConfigurationShared::Builder& builder) {
 
         // Untested applets
         if (setting->Id() == Settings::values.data_erase_applet_mode.Id() ||
+            setting->Id() == Settings::values.error_applet_mode.Id() ||
             setting->Id() == Settings::values.net_connect_applet_mode.Id() ||
+            setting->Id() == Settings::values.web_applet_mode.Id() ||
             setting->Id() == Settings::values.shop_applet_mode.Id() ||
             setting->Id() == Settings::values.login_share_applet_mode.Id() ||
             setting->Id() == Settings::values.wifi_web_auth_applet_mode.Id() ||

tools/reset-submodules.sh

@@ -1,8 +0,0 @@
-#!/bin/bash -ex
-
-# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
-# SPDX-License-Identifier: MIT
-
-git submodule sync
-git submodule foreach --recursive git reset --hard
-git submodule update --init --recursive