logging: Add DebuggerBackend for logging to Visual Studio

.travis/clang-format/script.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -ex
 
-if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .travis* dist/*.desktop \
+if grep -nr '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .travis* dist/*.desktop \
                  dist/*.svg dist/*.xml; then
     echo Trailing whitespace found, aborting
     exit 1

CMakeLists.txt

@@ -170,7 +170,7 @@ endif()
 # On modern Unixes, this is typically already the case. The lone exception is
 # glibc, which may default to 32 bits. glibc allows this to be configured
 # by setting _FILE_OFFSET_BITS.
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     add_definitions(-D_FILE_OFFSET_BITS=64)
 endif()
 

src/audio_core/audio_renderer.cpp

@@ -30,7 +30,7 @@ public:
         return info;
     }
 
-    VoiceInfo& GetInfo() {
+    VoiceInfo& Info() {
         return info;
     }
 
@@ -51,30 +51,9 @@ private:
     VoiceInfo info{};
 };
 
-class AudioRenderer::EffectState {
-public:
-    const EffectOutStatus& GetOutStatus() const {
-        return out_status;
-    }
-
-    const EffectInStatus& GetInfo() const {
-        return info;
-    }
-
-    EffectInStatus& GetInfo() {
-        return info;
-    }
-
-    void UpdateState();
-
-private:
-    EffectOutStatus out_status{};
-    EffectInStatus info{};
-};
 AudioRenderer::AudioRenderer(AudioRendererParameter params,
                              Kernel::SharedPtr<Kernel::Event> buffer_event)
-    : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
-      effects(params.effect_count) {
+    : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count) {
 
     audio_out = std::make_unique<AudioCore::AudioOut>();
     stream = audio_out->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
@@ -117,29 +96,11 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
                 memory_pool_count * sizeof(MemoryPoolInfo));
 
     // Copy VoiceInfo structs
-    std::size_t voice_offset{sizeof(UpdateDataHeader) + config.behavior_size +
-                             config.memory_pools_size + config.voice_resource_size};
+    std::size_t offset{sizeof(UpdateDataHeader) + config.behavior_size + config.memory_pools_size +
+                       config.voice_resource_size};
     for (auto& voice : voices) {
-        std::memcpy(&voice.GetInfo(), input_params.data() + voice_offset, sizeof(VoiceInfo));
-        voice_offset += sizeof(VoiceInfo);
-    }
-
-    std::size_t effect_offset{sizeof(UpdateDataHeader) + config.behavior_size +
-                              config.memory_pools_size + config.voice_resource_size +
-                              config.voices_size};
-    for (auto& effect : effects) {
-        std::memcpy(&effect.GetInfo(), input_params.data() + effect_offset, sizeof(EffectInStatus));
-        effect_offset += sizeof(EffectInStatus);
-    }
-
-    // Update memory pool state
-    std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
-    for (std::size_t index = 0; index < memory_pool.size(); ++index) {
-        if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestAttach) {
-            memory_pool[index].state = MemoryPoolStates::Attached;
-        } else if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestDetach) {
-            memory_pool[index].state = MemoryPoolStates::Detached;
-        }
+        std::memcpy(&voice.Info(), input_params.data() + offset, sizeof(VoiceInfo));
+        offset += sizeof(VoiceInfo);
     }
 
     // Update voices
@@ -153,8 +114,14 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
         }
     }
 
-    for (auto& effect : effects) {
-        effect.UpdateState();
+    // Update memory pool state
+    std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
+    for (std::size_t index = 0; index < memory_pool.size(); ++index) {
+        if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestAttach) {
+            memory_pool[index].state = MemoryPoolStates::Attached;
+        } else if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestDetach) {
+            memory_pool[index].state = MemoryPoolStates::Detached;
+        }
     }
 
     // Release previous buffers and queue next ones for playback
@@ -177,14 +144,6 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
         voice_out_status_offset += sizeof(VoiceOutStatus);
     }
 
-    std::size_t effect_out_status_offset{
-        sizeof(UpdateDataHeader) + response_data.memory_pools_size + response_data.voices_size +
-        response_data.voice_resource_size};
-    for (const auto& effect : effects) {
-        std::memcpy(output_params.data() + effect_out_status_offset, &effect.GetOutStatus(),
-                    sizeof(EffectOutStatus));
-        effect_out_status_offset += sizeof(EffectOutStatus);
-    }
     return output_params;
 }
 
@@ -285,29 +244,11 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
         break;
     }
 
-    samples =
-        Interpolate(interp_state, std::move(samples), GetInfo().sample_rate, STREAM_SAMPLE_RATE);
+    samples = Interpolate(interp_state, std::move(samples), Info().sample_rate, STREAM_SAMPLE_RATE);
 
     is_refresh_pending = false;
 }
 
-void AudioRenderer::EffectState::UpdateState() {
-    if (info.is_new) {
-        out_status.state = EffectStatus::New;
-    } else {
-        if (info.type == Effect::Aux) {
-            ASSERT_MSG(Memory::Read32(info.aux_info.return_buffer_info) == 0,
-                       "Aux buffers tried to update");
-            ASSERT_MSG(Memory::Read32(info.aux_info.send_buffer_info) == 0,
-                       "Aux buffers tried to update");
-            ASSERT_MSG(Memory::Read32(info.aux_info.return_buffer_base) == 0,
-                       "Aux buffers tried to update");
-            ASSERT_MSG(Memory::Read32(info.aux_info.send_buffer_base) == 0,
-                       "Aux buffers tried to update");
-        }
-    }
-}
-
 static constexpr s16 ClampToS16(s32 value) {
     return static_cast<s16>(std::clamp(value, -32768, 32767));
 }

src/audio_core/audio_renderer.h

@@ -28,16 +28,6 @@ enum class PlayState : u8 {
     Paused = 2,
 };
 
-enum class Effect : u8 {
-    None = 0,
-    Aux = 2,
-};
-
-enum class EffectStatus : u8 {
-    None = 0,
-    New = 1,
-};
-
 struct AudioRendererParameter {
     u32_le sample_rate;
     u32_le sample_count;
@@ -138,43 +128,6 @@ struct VoiceOutStatus {
 };
 static_assert(sizeof(VoiceOutStatus) == 0x10, "VoiceOutStatus has wrong size");
 
-struct AuxInfo {
-    std::array<u8, 24> input_mix_buffers;
-    std::array<u8, 24> output_mix_buffers;
-    u32_le mix_buffer_count;
-    u32_le sample_rate; // Stored in the aux buffer currently
-    u32_le sampe_count;
-    u64_le send_buffer_info;
-    u64_le send_buffer_base;
-
-    u64_le return_buffer_info;
-    u64_le return_buffer_base;
-};
-static_assert(sizeof(AuxInfo) == 0x60, "AuxInfo is an invalid size");
-
-struct EffectInStatus {
-    Effect type;
-    u8 is_new;
-    u8 is_enabled;
-    INSERT_PADDING_BYTES(1);
-    u32_le mix_id;
-    u64_le buffer_base;
-    u64_le buffer_sz;
-    s32_le priority;
-    INSERT_PADDING_BYTES(4);
-    union {
-        std::array<u8, 0xa0> raw;
-        AuxInfo aux_info;
-    };
-};
-static_assert(sizeof(EffectInStatus) == 0xc0, "EffectInStatus is an invalid size");
-
-struct EffectOutStatus {
-    EffectStatus state;
-    INSERT_PADDING_BYTES(0xf);
-};
-static_assert(sizeof(EffectOutStatus) == 0x10, "EffectOutStatus is an invalid size");
-
 struct UpdateDataHeader {
     UpdateDataHeader() {}
 
@@ -220,13 +173,11 @@ public:
     Stream::State GetStreamState() const;
 
 private:
-    class EffectState;
     class VoiceState;
 
     AudioRendererParameter worker_params;
     Kernel::SharedPtr<Kernel::Event> buffer_event;
     std::vector<VoiceState> voices;
-    std::vector<EffectState> effects;
     std::unique_ptr<AudioOut> audio_out;
     AudioCore::StreamPtr stream;
 };

src/common/CMakeLists.txt

@@ -29,7 +29,7 @@ if ($ENV{CI})
       if (BUILD_VERSION)
         # This leaves a trailing space on the last word, but we actually want that
         # because of how it's styled in the title bar.
-        set(BUILD_FULLNAME "${REPO_NAME} ${BUILD_VERSION} ")
+        set(BUILD_FULLNAME "${REPO_NAME} #${BUILD_VERSION} ")
       else()
         set(BUILD_FULLNAME "")
       endif()

src/common/alignment.h

@@ -19,16 +19,4 @@ constexpr T AlignDown(T value, std::size_t size) {
     return static_cast<T>(value - value % size);
 }
 
-template <typename T>
-constexpr bool Is4KBAligned(T value) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-    return (value & 0xFFF) == 0;
-}
-
-template <typename T>
-constexpr bool IsWordAligned(T value) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-    return (value & 0b11) == 0;
-}
-
 } // namespace Common

src/common/file_util.cpp

@@ -15,24 +15,21 @@
 #ifdef _WIN32
 #include <windows.h>
 // windows.h needs to be included before other windows headers
-#include <direct.h> // getcwd
+#include <commdlg.h> // for GetSaveFileName
+#include <direct.h>  // getcwd
 #include <io.h>
 #include <shellapi.h>
 #include <shlobj.h> // for SHGetFolderPath
 #include <tchar.h>
 #include "common/string_util.h"
 
-#ifdef _MSC_VER
-// 64 bit offsets for MSVC
+// 64 bit offsets for windows
 #define fseeko _fseeki64
 #define ftello _ftelli64
-#define fileno _fileno
-#endif
-
-// 64 bit offsets for MSVC and MinGW. MinGW also needs this for using _wstat64
+#define atoll _atoi64
 #define stat _stat64
 #define fstat _fstat64
-
+#define fileno _fileno
 #else
 #ifdef __APPLE__
 #include <sys/param.h>

src/common/hex_util.cpp

@@ -18,25 +18,6 @@ u8 ToHexNibble(char c1) {
     return 0;
 }
 
-std::vector<u8> HexStringToVector(std::string_view str, bool little_endian) {
-    std::vector<u8> out(str.size() / 2);
-    if (little_endian) {
-        for (std::size_t i = str.size() - 2; i <= str.size(); i -= 2)
-            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
-    } else {
-        for (std::size_t i = 0; i < str.size(); i += 2)
-            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
-    }
-    return out;
-}
-
-std::string HexVectorToString(const std::vector<u8>& vector, bool upper) {
-    std::string out;
-    for (u8 c : vector)
-        out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
-    return out;
-}
-
 std::array<u8, 16> operator""_array16(const char* str, std::size_t len) {
     if (len != 32) {
         LOG_ERROR(Common,

src/common/hex_util.h

@@ -7,7 +7,6 @@
 #include <array>
 #include <cstddef>
 #include <string>
-#include <vector>
 #include <fmt/format.h>
 #include "common/common_types.h"
 
@@ -15,8 +14,6 @@ namespace Common {
 
 u8 ToHexNibble(char c1);
 
-std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
-
 template <std::size_t Size, bool le = false>
 std::array<u8, Size> HexStringToArray(std::string_view str) {
     std::array<u8, Size> out{};
@@ -30,8 +27,6 @@ std::array<u8, Size> HexStringToArray(std::string_view str) {
     return out;
 }
 
-std::string HexVectorToString(const std::vector<u8>& vector, bool upper = true);
-
 template <std::size_t Size>
 std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
     std::string out;

src/common/logging/backend.cpp

@@ -12,7 +12,8 @@
 #include <thread>
 #include <vector>
 #ifdef _WIN32
-#include <share.h> // For _SH_DENYWR
+#include <share.h>   // For _SH_DENYWR
+#include <windows.h> // For OutputDebugStringA
 #else
 #define _SH_DENYWR 0
 #endif
@@ -139,12 +140,18 @@ void FileBackend::Write(const Entry& entry) {
     if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
         return;
     }
-    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
+    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
     if (entry.log_level >= Level::Error) {
         file.Flush();
     }
 }
 
+void DebuggerBackend::Write(const Entry& entry) {
+#ifdef _WIN32
+    ::OutputDebugStringA(FormatLogMessage(entry).append(1, '\n').c_str());
+#endif
+}
+
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
     CLS(Log)                                                                                       \

src/common/logging/backend.h

@@ -103,6 +103,20 @@ private:
     std::size_t bytes_written;
 };
 
+/**
+ * Backend that writes to Visual Studio's output window
+ */
+class DebuggerBackend : public Backend {
+public:
+    static const char* Name() {
+        return "debugger";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
 void AddBackend(std::unique_ptr<Backend> backend);
 
 void RemoveBackend(std::string_view backend_name);

src/common/logging/log.h

@@ -91,7 +91,6 @@ enum class Class : ClassType {
     Service_PM,        ///< The PM service
     Service_PREPO,     ///< The PREPO (Play report) service
     Service_PSC,       ///< The PSC service
-    Service_PSM,       ///< The PSM service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
     Service_SPL,       ///< The SPL service

src/common/param_package.cpp

@@ -20,15 +20,7 @@ constexpr char KEY_VALUE_SEPARATOR_ESCAPE[] = "$0";
 constexpr char PARAM_SEPARATOR_ESCAPE[] = "$1";
 constexpr char ESCAPE_CHARACTER_ESCAPE[] = "$2";
 
-/// A placeholder for empty param packages to avoid empty strings
-/// (they may be recognized as "not set" by some frontend libraries like qt)
-constexpr char EMPTY_PLACEHOLDER[] = "[empty]";
-
 ParamPackage::ParamPackage(const std::string& serialized) {
-    if (serialized == EMPTY_PLACEHOLDER) {
-        return;
-    }
-
     std::vector<std::string> pairs;
     Common::SplitString(serialized, PARAM_SEPARATOR, pairs);
 
@@ -54,7 +46,7 @@ ParamPackage::ParamPackage(std::initializer_list<DataType::value_type> list) : d
 
 std::string ParamPackage::Serialize() const {
     if (data.empty())
-        return EMPTY_PLACEHOLDER;
+        return "";
 
     std::string result;
 
@@ -128,12 +120,4 @@ bool ParamPackage::Has(const std::string& key) const {
     return data.find(key) != data.end();
 }
 
-void ParamPackage::Erase(const std::string& key) {
-    data.erase(key);
-}
-
-void ParamPackage::Clear() {
-    data.clear();
-}
-
 } // namespace Common

src/common/param_package.h

@@ -32,8 +32,6 @@ public:
     void Set(const std::string& key, int value);
     void Set(const std::string& key, float value);
     bool Has(const std::string& key) const;
-    void Erase(const std::string& key);
-    void Clear();
 
 private:
     DataType data;

src/common/web_result.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <string>
-#include "common/common_types.h"
 
 namespace Common {
 struct WebResult {

src/core/CMakeLists.txt

@@ -18,8 +18,6 @@ add_library(core STATIC
     crypto/encryption_layer.h
     crypto/key_manager.cpp
     crypto/key_manager.h
-    crypto/partition_data_manager.cpp
-    crypto/partition_data_manager.h
     crypto/ctr_encryption_layer.cpp
     crypto/ctr_encryption_layer.h
     crypto/xts_encryption_layer.cpp
@@ -72,7 +70,6 @@ add_library(core STATIC
     file_sys/vfs_real.cpp
     file_sys/vfs_real.h
     file_sys/vfs_static.h
-    file_sys/vfs_types.h
     file_sys/vfs_vector.cpp
     file_sys/vfs_vector.h
     file_sys/xts_archive.cpp
@@ -156,8 +153,6 @@ add_library(core STATIC
     hle/service/am/omm.h
     hle/service/am/spsm.cpp
     hle/service/am/spsm.h
-    hle/service/am/tcap.cpp
-    hle/service/am/tcap.h
     hle/service/aoc/aoc_u.cpp
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
@@ -238,24 +233,6 @@ add_library(core STATIC
     hle/service/hid/irs.h
     hle/service/hid/xcd.cpp
     hle/service/hid/xcd.h
-    hle/service/hid/controllers/controller_base.cpp
-    hle/service/hid/controllers/controller_base.h
-    hle/service/hid/controllers/debug_pad.cpp
-    hle/service/hid/controllers/debug_pad.h
-    hle/service/hid/controllers/gesture.cpp
-    hle/service/hid/controllers/gesture.h
-    hle/service/hid/controllers/keyboard.cpp
-    hle/service/hid/controllers/keyboard.h
-    hle/service/hid/controllers/mouse.cpp
-    hle/service/hid/controllers/mouse.h
-    hle/service/hid/controllers/npad.cpp
-    hle/service/hid/controllers/npad.h
-    hle/service/hid/controllers/stubbed.cpp
-    hle/service/hid/controllers/stubbed.h
-    hle/service/hid/controllers/touchscreen.cpp
-    hle/service/hid/controllers/touchscreen.h
-    hle/service/hid/controllers/xpad.cpp
-    hle/service/hid/controllers/xpad.h
     hle/service/lbl/lbl.cpp
     hle/service/lbl/lbl.h
     hle/service/ldn/ldn.cpp
@@ -282,8 +259,6 @@ add_library(core STATIC
     hle/service/nifm/nifm.h
     hle/service/nim/nim.cpp
     hle/service/nim/nim.h
-    hle/service/npns/npns.cpp
-    hle/service/npns/npns.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -331,8 +306,6 @@ add_library(core STATIC
     hle/service/prepo/prepo.h
     hle/service/psc/psc.cpp
     hle/service/psc/psc.h
-    hle/service/ptm/psm.cpp
-    hle/service/ptm/psm.h
     hle/service/service.cpp
     hle/service/service.h
     hle/service/set/set.cpp
@@ -424,8 +397,8 @@ create_target_directory_groups(core)
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
 target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn open_source_archives)
 if (ENABLE_WEB_SERVICE)
-    target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
-    target_link_libraries(core PRIVATE web_service)
+    add_definitions(-DENABLE_WEB_SERVICE)
+    target_link_libraries(core PUBLIC json-headers web_service)
 endif()
 
 if (ARCHITECTURE_x86_64)

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -129,7 +129,7 @@ public:
 };
 
 std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
-    auto* current_process = Core::CurrentProcess();
+    auto& current_process = Core::CurrentProcess();
     auto** const page_table = current_process->VMManager().page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
@@ -144,7 +144,7 @@ std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
 
     // Multi-process state
     config.processor_id = core_index;
-    config.global_monitor = &exclusive_monitor.monitor;
+    config.global_monitor = &exclusive_monitor->monitor;
 
     // System registers
     config.tpidrro_el0 = &cb->tpidrro_el0;
@@ -171,9 +171,10 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(ExclusiveMonitor& exclusive_monitor, std::size_t core_index)
+ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+                           std::size_t core_index)
     : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {
+      exclusive_monitor{std::dynamic_pointer_cast<DynarmicExclusiveMonitor>(exclusive_monitor)} {
     ThreadContext ctx{};
     inner_unicorn.SaveContext(ctx);
     PageTableChanged();

src/core/arm/dynarmic/arm_dynarmic.h

@@ -23,7 +23,7 @@ class DynarmicExclusiveMonitor;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic(ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
+    ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, std::size_t core_index);
     ~ARM_Dynarmic();
 
     void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
@@ -62,7 +62,7 @@ private:
     ARM_Unicorn inner_unicorn;
 
     std::size_t core_index;
-    DynarmicExclusiveMonitor& exclusive_monitor;
+    std::shared_ptr<DynarmicExclusiveMonitor> exclusive_monitor;
 
     Memory::PageTable* current_page_table = nullptr;
 };

src/core/core.cpp

@@ -71,9 +71,9 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 }
 
 /// Runs a CPU core while the system is powered on
-void RunCpuCore(Cpu& cpu_state) {
+void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
     while (Core::System::GetInstance().IsPoweredOn()) {
-        cpu_state.RunLoop(true);
+        cpu_state->RunLoop(true);
     }
 }
 } // Anonymous namespace
@@ -95,7 +95,7 @@ struct System::Impl {
         status = ResultStatus::Success;
 
         // Update thread_to_cpu in case Core 0 is run from a different host thread
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
+        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
 
         if (GDBStub::IsServerEnabled()) {
             GDBStub::HandlePacket();
@@ -136,19 +136,18 @@ struct System::Impl {
         if (virtual_filesystem == nullptr)
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
 
-        auto main_process = Kernel::Process::Create(kernel, "main");
-        kernel.MakeCurrentProcess(main_process.get());
+        kernel.MakeCurrentProcess(Kernel::Process::Create(kernel, "main"));
 
-        cpu_barrier = std::make_unique<CpuBarrier>();
+        cpu_barrier = std::make_shared<CpuBarrier>();
         cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
         for (std::size_t index = 0; index < cpu_cores.size(); ++index) {
-            cpu_cores[index] = std::make_unique<Cpu>(*cpu_exclusive_monitor, *cpu_barrier, index);
+            cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
         }
 
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-        Service::Init(service_manager, *virtual_filesystem);
+        Service::Init(service_manager, virtual_filesystem);
         GDBStub::Init();
 
         renderer = VideoCore::CreateRenderer(emu_window);
@@ -160,12 +159,12 @@ struct System::Impl {
 
         // Create threads for CPU cores 1-3, and build thread_to_cpu map
         // CPU core 0 is run on the main thread
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0].get();
+        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
         if (Settings::values.use_multi_core) {
             for (std::size_t index = 0; index < cpu_core_threads.size(); ++index) {
                 cpu_core_threads[index] =
-                    std::make_unique<std::thread>(RunCpuCore, std::ref(*cpu_cores[index + 1]));
-                thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1].get();
+                    std::make_unique<std::thread>(RunCpuCore, cpu_cores[index + 1]);
+                thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1];
             }
         }
 
@@ -245,7 +244,6 @@ struct System::Impl {
         for (auto& cpu_core : cpu_cores) {
             cpu_core.reset();
         }
-        cpu_exclusive_monitor.reset();
         cpu_barrier.reset();
 
         // Shutdown kernel and core timing
@@ -283,9 +281,9 @@ struct System::Impl {
     std::unique_ptr<VideoCore::RendererBase> renderer;
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
-    std::unique_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
-    std::unique_ptr<CpuBarrier> cpu_barrier;
-    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
+    std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
+    std::shared_ptr<CpuBarrier> cpu_barrier;
+    std::array<std::shared_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
     std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
     std::size_t active_core{}; ///< Active core, only used in single thread mode
 
@@ -299,7 +297,7 @@ struct System::Impl {
     std::string status_details = "";
 
     /// Map of guest threads to CPU cores
-    std::map<std::thread::id, Cpu*> thread_to_cpu;
+    std::map<std::thread::id, std::shared_ptr<Cpu>> thread_to_cpu;
 
     Core::PerfStats perf_stats;
     Core::FrameLimiter frame_limiter;
@@ -355,27 +353,25 @@ std::size_t System::CurrentCoreIndex() {
 }
 
 Kernel::Scheduler& System::CurrentScheduler() {
-    return CurrentCpuCore().Scheduler();
+    return *CurrentCpuCore().Scheduler();
 }
 
-Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
-    return CpuCore(core_index).Scheduler();
+const std::shared_ptr<Kernel::Scheduler>& System::Scheduler(std::size_t core_index) {
+    ASSERT(core_index < NUM_CPU_CORES);
+    return impl->cpu_cores[core_index]->Scheduler();
 }
 
-const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
-    return CpuCore(core_index).Scheduler();
-}
-
-Kernel::Process* System::CurrentProcess() {
+Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() {
     return impl->kernel.CurrentProcess();
 }
 
-const Kernel::Process* System::CurrentProcess() const {
+const Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() const {
     return impl->kernel.CurrentProcess();
 }
 
 ARM_Interface& System::ArmInterface(std::size_t core_index) {
-    return CpuCore(core_index).ArmInterface();
+    ASSERT(core_index < NUM_CPU_CORES);
+    return impl->cpu_cores[core_index]->ArmInterface();
 }
 
 Cpu& System::CpuCore(std::size_t core_index) {
@@ -383,11 +379,6 @@ Cpu& System::CpuCore(std::size_t core_index) {
     return *impl->cpu_cores[core_index];
 }
 
-const Cpu& System::CpuCore(std::size_t core_index) const {
-    ASSERT(core_index < NUM_CPU_CORES);
-    return *impl->cpu_cores[core_index];
-}
-
 ExclusiveMonitor& System::Monitor() {
     return *impl->cpu_exclusive_monitor;
 }

src/core/core.h

@@ -156,9 +156,6 @@ public:
     /// Gets a CPU interface to the CPU core with the specified index
     Cpu& CpuCore(std::size_t core_index);
 
-    /// Gets a CPU interface to the CPU core with the specified index
-    const Cpu& CpuCore(std::size_t core_index) const;
-
     /// Gets the exclusive monitor
     ExclusiveMonitor& Monitor();
 
@@ -175,16 +172,13 @@ public:
     const VideoCore::RendererBase& Renderer() const;
 
     /// Gets the scheduler for the CPU core with the specified index
-    Kernel::Scheduler& Scheduler(std::size_t core_index);
+    const std::shared_ptr<Kernel::Scheduler>& Scheduler(std::size_t core_index);
 
-    /// Gets the scheduler for the CPU core with the specified index
-    const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
+    /// Provides a reference to the current process
+    Kernel::SharedPtr<Kernel::Process>& CurrentProcess();
 
-    /// Provides a pointer to the current process
-    Kernel::Process* CurrentProcess();
-
-    /// Provides a constant pointer to the current process.
-    const Kernel::Process* CurrentProcess() const;
+    /// Provides a constant reference to the current process.
+    const Kernel::SharedPtr<Kernel::Process>& CurrentProcess() const;
 
     /// Provides a reference to the kernel instance.
     Kernel::KernelCore& Kernel();
@@ -252,7 +246,7 @@ inline TelemetrySession& Telemetry() {
     return System::GetInstance().TelemetrySession();
 }
 
-inline Kernel::Process* CurrentProcess() {
+inline Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
     return System::GetInstance().CurrentProcess();
 }
 

src/core/core_cpu.cpp

@@ -49,8 +49,10 @@ bool CpuBarrier::Rendezvous() {
     return false;
 }
 
-Cpu::Cpu(ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier, std::size_t core_index)
-    : cpu_barrier{cpu_barrier}, core_index{core_index} {
+Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+         std::shared_ptr<CpuBarrier> cpu_barrier, std::size_t core_index)
+    : cpu_barrier{std::move(cpu_barrier)}, core_index{core_index} {
+
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
         arm_interface = std::make_unique<ARM_Dynarmic>(exclusive_monitor, core_index);
@@ -62,15 +64,15 @@ Cpu::Cpu(ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier, std::size
         arm_interface = std::make_unique<ARM_Unicorn>();
     }
 
-    scheduler = std::make_unique<Kernel::Scheduler>(*arm_interface);
+    scheduler = std::make_shared<Kernel::Scheduler>(*arm_interface);
 }
 
 Cpu::~Cpu() = default;
 
-std::unique_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(std::size_t num_cores) {
+std::shared_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(std::size_t num_cores) {
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-        return std::make_unique<DynarmicExclusiveMonitor>(num_cores);
+        return std::make_shared<DynarmicExclusiveMonitor>(num_cores);
 #else
         return nullptr; // TODO(merry): Passthrough exclusive monitor
 #endif
@@ -81,7 +83,7 @@ std::unique_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(std::size_t num_core
 
 void Cpu::RunLoop(bool tight_loop) {
     // Wait for all other CPU cores to complete the previous slice, such that they run in lock-step
-    if (!cpu_barrier.Rendezvous()) {
+    if (!cpu_barrier->Rendezvous()) {
         // If rendezvous failed, session has been killed
         return;
     }

src/core/core_cpu.h

@@ -41,7 +41,8 @@ private:
 
 class Cpu {
 public:
-    Cpu(ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier, std::size_t core_index);
+    Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+        std::shared_ptr<CpuBarrier> cpu_barrier, std::size_t core_index);
     ~Cpu();
 
     void RunLoop(bool tight_loop = true);
@@ -58,12 +59,8 @@ public:
         return *arm_interface;
     }
 
-    Kernel::Scheduler& Scheduler() {
-        return *scheduler;
-    }
-
-    const Kernel::Scheduler& Scheduler() const {
-        return *scheduler;
+    const std::shared_ptr<Kernel::Scheduler>& Scheduler() const {
+        return scheduler;
     }
 
     bool IsMainCore() const {
@@ -74,14 +71,14 @@ public:
         return core_index;
     }
 
-    static std::unique_ptr<ExclusiveMonitor> MakeExclusiveMonitor(std::size_t num_cores);
+    static std::shared_ptr<ExclusiveMonitor> MakeExclusiveMonitor(std::size_t num_cores);
 
 private:
     void Reschedule();
 
     std::unique_ptr<ARM_Interface> arm_interface;
-    CpuBarrier& cpu_barrier;
-    std::unique_ptr<Kernel::Scheduler> scheduler;
+    std::shared_ptr<CpuBarrier> cpu_barrier;
+    std::shared_ptr<Kernel::Scheduler> scheduler;
 
     std::atomic<bool> reschedule_pending = false;
     std::size_t core_index;

src/core/crypto/key_manager.cpp

@@ -4,56 +4,23 @@
 
 #include <algorithm>
 #include <array>
-#include <bitset>
-#include <cctype>
 #include <fstream>
 #include <locale>
-#include <map>
 #include <sstream>
 #include <string_view>
 #include <tuple>
 #include <vector>
-#include <mbedtls/bignum.h>
-#include <mbedtls/cipher.h>
-#include <mbedtls/cmac.h>
-#include <mbedtls/sha256.h>
-#include "common/common_funcs.h"
 #include "common/common_paths.h"
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
-#include "core/crypto/partition_data_manager.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 #include "core/settings.h"
 
 namespace Core::Crypto {
 
-constexpr u64 CURRENT_CRYPTO_REVISION = 0x5;
-
-using namespace Common;
-
-const std::array<SHA256Hash, 2> eticket_source_hashes{
-    "B71DB271DC338DF380AA2C4335EF8873B1AFD408E80B3582D8719FC81C5E511C"_array32, // eticket_rsa_kek_source
-    "E8965A187D30E57869F562D04383C996DE487BBA5761363D2D4D32391866A85C"_array32, // eticket_rsa_kekek_source
-};
-
-const std::map<std::pair<S128KeyType, u64>, std::string> KEYS_VARIABLE_LENGTH{
-    {{S128KeyType::Master, 0}, "master_key_"},
-    {{S128KeyType::Package1, 0}, "package1_key_"},
-    {{S128KeyType::Package2, 0}, "package2_key_"},
-    {{S128KeyType::Titlekek, 0}, "titlekek_"},
-    {{S128KeyType::Source, static_cast<u64>(SourceKeyType::Keyblob)}, "keyblob_key_source_"},
-    {{S128KeyType::Keyblob, 0}, "keyblob_key_"},
-    {{S128KeyType::KeyblobMAC, 0}, "keyblob_mac_key_"},
-};
-
 Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed) {
     Key128 out{};
 
@@ -70,136 +37,57 @@ Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, K
     return out;
 }
 
-Key128 DeriveKeyblobKey(const Key128& sbk, const Key128& tsec, Key128 source) {
-    AESCipher<Key128> sbk_cipher(sbk, Mode::ECB);
-    AESCipher<Key128> tsec_cipher(tsec, Mode::ECB);
-    tsec_cipher.Transcode(source.data(), source.size(), source.data(), Op::Decrypt);
-    sbk_cipher.Transcode(source.data(), source.size(), source.data(), Op::Decrypt);
-    return source;
-}
-
-Key128 DeriveMasterKey(const std::array<u8, 0x90>& keyblob, const Key128& master_source) {
-    Key128 master_root;
-    std::memcpy(master_root.data(), keyblob.data(), sizeof(Key128));
-
-    AESCipher<Key128> master_cipher(master_root, Mode::ECB);
-
-    Key128 master{};
-    master_cipher.Transcode(master_source.data(), master_source.size(), master.data(), Op::Decrypt);
-    return master;
-}
-
-std::array<u8, 144> DecryptKeyblob(const std::array<u8, 176>& encrypted_keyblob,
-                                   const Key128& key) {
-    std::array<u8, 0x90> keyblob;
-    AESCipher<Key128> cipher(key, Mode::CTR);
-    cipher.SetIV(std::vector<u8>(encrypted_keyblob.data() + 0x10, encrypted_keyblob.data() + 0x20));
-    cipher.Transcode(encrypted_keyblob.data() + 0x20, keyblob.size(), keyblob.data(), Op::Decrypt);
-    return keyblob;
-}
-
-void KeyManager::DeriveGeneralPurposeKeys(std::size_t crypto_revision) {
-    const auto kek_generation_source =
-        GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKekGeneration));
-    const auto key_generation_source =
-        GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration));
-
-    if (HasKey(S128KeyType::Master, crypto_revision)) {
-        for (auto kak_type :
-             {KeyAreaKeyType::Application, KeyAreaKeyType::Ocean, KeyAreaKeyType::System}) {
-            if (HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyAreaKey),
-                       static_cast<u64>(kak_type))) {
-                const auto source =
-                    GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyAreaKey),
-                           static_cast<u64>(kak_type));
-                const auto kek =
-                    GenerateKeyEncryptionKey(source, GetKey(S128KeyType::Master, crypto_revision),
-                                             kek_generation_source, key_generation_source);
-                SetKey(S128KeyType::KeyArea, kek, crypto_revision, static_cast<u64>(kak_type));
-            }
-        }
-
-        AESCipher<Key128> master_cipher(GetKey(S128KeyType::Master, crypto_revision), Mode::ECB);
-        for (auto key_type : {SourceKeyType::Titlekek, SourceKeyType::Package2}) {
-            if (HasKey(S128KeyType::Source, static_cast<u64>(key_type))) {
-                Key128 key{};
-                master_cipher.Transcode(
-                    GetKey(S128KeyType::Source, static_cast<u64>(key_type)).data(), key.size(),
-                    key.data(), Op::Decrypt);
-                SetKey(key_type == SourceKeyType::Titlekek ? S128KeyType::Titlekek
-                                                           : S128KeyType::Package2,
-                       key, crypto_revision);
-            }
-        }
-    }
-}
-
-Key128 DeriveKeyblobMACKey(const Key128& keyblob_key, const Key128& mac_source) {
-    AESCipher<Key128> mac_cipher(keyblob_key, Mode::ECB);
-    Key128 mac_key{};
-    mac_cipher.Transcode(mac_source.data(), mac_key.size(), mac_key.data(), Op::Decrypt);
-    return mac_key;
-}
-
 boost::optional<Key128> DeriveSDSeed() {
     const FileUtil::IOFile save_43(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                                        "/system/save/8000000000000043",
                                    "rb+");
     if (!save_43.IsOpen())
         return boost::none;
-
     const FileUtil::IOFile sd_private(
         FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir) + "/Nintendo/Contents/private", "rb+");
     if (!sd_private.IsOpen())
         return boost::none;
 
+    sd_private.Seek(0, SEEK_SET);
     std::array<u8, 0x10> private_seed{};
-    if (sd_private.ReadBytes(private_seed.data(), private_seed.size()) != private_seed.size()) {
+    if (sd_private.ReadBytes(private_seed.data(), private_seed.size()) != 0x10)
         return boost::none;
-    }
 
     std::array<u8, 0x10> buffer{};
     std::size_t offset = 0;
     for (; offset + 0x10 < save_43.GetSize(); ++offset) {
-        if (!save_43.Seek(offset, SEEK_SET)) {
-            return boost::none;
-        }
-
+        save_43.Seek(offset, SEEK_SET);
         save_43.ReadBytes(buffer.data(), buffer.size());
-        if (buffer == private_seed) {
+        if (buffer == private_seed)
             break;
-        }
     }
 
-    if (!save_43.Seek(offset + 0x10, SEEK_SET)) {
+    if (offset + 0x10 >= save_43.GetSize())
         return boost::none;
-    }
 
     Key128 seed{};
-    if (save_43.ReadBytes(seed.data(), seed.size()) != seed.size()) {
-        return boost::none;
-    }
+    save_43.Seek(offset + 0x10, SEEK_SET);
+    save_43.ReadBytes(seed.data(), seed.size());
     return seed;
 }
 
-Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& keys) {
-    if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKek)))
+Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, const KeyManager& keys) {
+    if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKEK)))
         return Loader::ResultStatus::ErrorMissingSDKEKSource;
-    if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKekGeneration)))
+    if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKEKGeneration)))
         return Loader::ResultStatus::ErrorMissingAESKEKGenerationSource;
     if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration)))
         return Loader::ResultStatus::ErrorMissingAESKeyGenerationSource;
 
     const auto sd_kek_source =
-        keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKek));
+        keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKEK));
     const auto aes_kek_gen =
-        keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKekGeneration));
+        keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKEKGeneration));
     const auto aes_key_gen =
         keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration));
     const auto master_00 = keys.GetKey(S128KeyType::Master);
     const auto sd_kek =
         GenerateKeyEncryptionKey(sd_kek_source, master_00, aes_kek_gen, aes_key_gen);
-    keys.SetKey(S128KeyType::SDKek, sd_kek);
 
     if (!keys.HasKey(S128KeyType::SDSeed))
         return Loader::ResultStatus::ErrorMissingSDSeed;
@@ -230,147 +118,9 @@ Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& ke
                        return source; ///< Return unaltered source to satisfy output requirement.
                    });
 
-    keys.SetKey(S256KeyType::SDKey, sd_keys[0], static_cast<u64>(SDKeyType::Save));
-    keys.SetKey(S256KeyType::SDKey, sd_keys[1], static_cast<u64>(SDKeyType::NCA));
-
     return Loader::ResultStatus::Success;
 }
 
-std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save) {
-    if (!ticket_save.IsOpen())
-        return {};
-
-    std::vector<u8> buffer(ticket_save.GetSize());
-    if (ticket_save.ReadBytes(buffer.data(), buffer.size()) != buffer.size()) {
-        return {};
-    }
-
-    std::vector<TicketRaw> out;
-    u32 magic{};
-    for (std::size_t offset = 0; offset + 0x4 < buffer.size(); ++offset) {
-        if (buffer[offset] == 0x4 && buffer[offset + 1] == 0x0 && buffer[offset + 2] == 0x1 &&
-            buffer[offset + 3] == 0x0) {
-            out.emplace_back();
-            auto& next = out.back();
-            std::memcpy(&next, buffer.data() + offset, sizeof(TicketRaw));
-            offset += next.size();
-        }
-    }
-
-    return out;
-}
-
-template <size_t size>
-static std::array<u8, size> operator^(const std::array<u8, size>& lhs,
-                                      const std::array<u8, size>& rhs) {
-    std::array<u8, size> out{};
-    std::transform(lhs.begin(), lhs.end(), rhs.begin(), out.begin(), std::bit_xor<>());
-    return out;
-}
-
-template <size_t target_size, size_t in_size>
-static std::array<u8, target_size> MGF1(const std::array<u8, in_size>& seed) {
-    // Avoids truncation overflow within the loop below.
-    static_assert(target_size <= 0xFF);
-
-    std::array<u8, in_size + 4> seed_exp{};
-    std::memcpy(seed_exp.data(), seed.data(), in_size);
-
-    std::vector<u8> out;
-    size_t i = 0;
-    while (out.size() < target_size) {
-        out.resize(out.size() + 0x20);
-        seed_exp[in_size + 3] = static_cast<u8>(i);
-        mbedtls_sha256(seed_exp.data(), seed_exp.size(), out.data() + out.size() - 0x20, 0);
-        ++i;
-    }
-
-    std::array<u8, target_size> target;
-    std::memcpy(target.data(), out.data(), target_size);
-    return target;
-}
-
-template <size_t size>
-static boost::optional<u64> FindTicketOffset(const std::array<u8, size>& data) {
-    u64 offset = 0;
-    for (size_t i = 0x20; i < data.size() - 0x10; ++i) {
-        if (data[i] == 0x1) {
-            offset = i + 1;
-            break;
-        } else if (data[i] != 0x0) {
-            return boost::none;
-        }
-    }
-
-    return offset;
-}
-
-boost::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
-                                                       const RSAKeyPair<2048>& key) {
-    u32 cert_authority;
-    std::memcpy(&cert_authority, ticket.data() + 0x140, sizeof(cert_authority));
-    if (cert_authority == 0)
-        return boost::none;
-    if (cert_authority != Common::MakeMagic('R', 'o', 'o', 't')) {
-        LOG_INFO(Crypto,
-                 "Attempting to parse ticket with non-standard certificate authority {:08X}.",
-                 cert_authority);
-    }
-
-    Key128 rights_id;
-    std::memcpy(rights_id.data(), ticket.data() + 0x2A0, sizeof(Key128));
-
-    if (rights_id == Key128{})
-        return boost::none;
-
-    Key128 key_temp{};
-
-    if (!std::any_of(ticket.begin() + 0x190, ticket.begin() + 0x280, [](u8 b) { return b != 0; })) {
-        std::memcpy(key_temp.data(), ticket.data() + 0x180, key_temp.size());
-        return std::make_pair(rights_id, key_temp);
-    }
-
-    mbedtls_mpi D; // RSA Private Exponent
-    mbedtls_mpi N; // RSA Modulus
-    mbedtls_mpi S; // Input
-    mbedtls_mpi M; // Output
-
-    mbedtls_mpi_init(&D);
-    mbedtls_mpi_init(&N);
-    mbedtls_mpi_init(&S);
-    mbedtls_mpi_init(&M);
-
-    mbedtls_mpi_read_binary(&D, key.decryption_key.data(), key.decryption_key.size());
-    mbedtls_mpi_read_binary(&N, key.modulus.data(), key.modulus.size());
-    mbedtls_mpi_read_binary(&S, ticket.data() + 0x180, 0x100);
-
-    mbedtls_mpi_exp_mod(&M, &S, &D, &N, nullptr);
-
-    std::array<u8, 0x100> rsa_step;
-    mbedtls_mpi_write_binary(&M, rsa_step.data(), rsa_step.size());
-
-    u8 m_0 = rsa_step[0];
-    std::array<u8, 0x20> m_1;
-    std::memcpy(m_1.data(), rsa_step.data() + 0x01, m_1.size());
-    std::array<u8, 0xDF> m_2;
-    std::memcpy(m_2.data(), rsa_step.data() + 0x21, m_2.size());
-
-    if (m_0 != 0)
-        return boost::none;
-
-    m_1 = m_1 ^ MGF1<0x20>(m_2);
-    m_2 = m_2 ^ MGF1<0xDF>(m_1);
-
-    const auto offset = FindTicketOffset(m_2);
-    if (offset == boost::none)
-        return boost::none;
-    ASSERT(offset.get() > 0);
-
-    std::memcpy(key_temp.data(), m_2.data() + offset.get(), key_temp.size());
-
-    return std::make_pair(rights_id, key_temp);
-}
-
 KeyManager::KeyManager() {
     // Initialize keys
     const std::string hactool_keys_dir = FileUtil::GetHactoolConfigurationPath();
@@ -387,15 +137,6 @@ KeyManager::KeyManager() {
 
     AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "title.keys", true);
     AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "title.keys_autogenerated", true);
-    AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "console.keys", false);
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "console.keys_autogenerated", false);
-}
-
-static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_t length) {
-    if (base.size() < begin + length)
-        return false;
-    return std::all_of(base.begin() + begin, base.begin() + begin + length,
-                       [](u8 c) { return std::isdigit(c); });
 }
 
 void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
@@ -417,9 +158,6 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
         out[0].erase(std::remove(out[0].begin(), out[0].end(), ' '), out[0].end());
         out[1].erase(std::remove(out[1].begin(), out[1].end(), ' '), out[1].end());
 
-        if (out[0].compare(0, 1, "#") == 0)
-            continue;
-
         if (is_title_keys) {
             auto rights_id_raw = Common::HexStringToArray<16>(out[0]);
             u128 rights_id{};
@@ -436,50 +174,6 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
                 const auto index = s256_file_id.at(out[0]);
                 Key256 key = Common::HexStringToArray<32>(out[1]);
                 s256_keys[{index.type, index.field1, index.field2}] = key;
-            } else if (out[0].compare(0, 8, "keyblob_") == 0 &&
-                       out[0].compare(0, 9, "keyblob_k") != 0) {
-                if (!ValidCryptoRevisionString(out[0], 8, 2))
-                    continue;
-
-                const auto index = std::stoul(out[0].substr(8, 2), nullptr, 16);
-                keyblobs[index] = Common::HexStringToArray<0x90>(out[1]);
-            } else if (out[0].compare(0, 18, "encrypted_keyblob_") == 0) {
-                if (!ValidCryptoRevisionString(out[0], 18, 2))
-                    continue;
-
-                const auto index = std::stoul(out[0].substr(18, 2), nullptr, 16);
-                encrypted_keyblobs[index] = Common::HexStringToArray<0xB0>(out[1]);
-            } else {
-                for (const auto& kv : KEYS_VARIABLE_LENGTH) {
-                    if (!ValidCryptoRevisionString(out[0], kv.second.size(), 2))
-                        continue;
-                    if (out[0].compare(0, kv.second.size(), kv.second) == 0) {
-                        const auto index =
-                            std::stoul(out[0].substr(kv.second.size(), 2), nullptr, 16);
-                        const auto sub = kv.first.second;
-                        if (sub == 0) {
-                            s128_keys[{kv.first.first, index, 0}] =
-                                Common::HexStringToArray<16>(out[1]);
-                        } else {
-                            s128_keys[{kv.first.first, kv.first.second, index}] =
-                                Common::HexStringToArray<16>(out[1]);
-                        }
-
-                        break;
-                    }
-                }
-
-                static constexpr std::array<const char*, 3> kak_names = {
-                    "key_area_key_application_", "key_area_key_ocean_", "key_area_key_system_"};
-                for (size_t j = 0; j < kak_names.size(); ++j) {
-                    const auto& match = kak_names[j];
-                    if (out[0].compare(0, std::strlen(match), match) == 0) {
-                        const auto index =
-                            std::stoul(out[0].substr(std::strlen(match), 2), nullptr, 16);
-                        s128_keys[{S128KeyType::KeyArea, index, j}] =
-                            Common::HexStringToArray<16>(out[1]);
-                    }
-                }
             }
         }
     }
@@ -493,28 +187,6 @@ void KeyManager::AttemptLoadKeyFile(const std::string& dir1, const std::string&
         LoadFromFile(dir2 + DIR_SEP + filename, title);
 }
 
-bool KeyManager::BaseDeriveNecessary() const {
-    const auto check_key_existence = [this](auto key_type, u64 index1 = 0, u64 index2 = 0) {
-        return !HasKey(key_type, index1, index2);
-    };
-
-    if (check_key_existence(S256KeyType::Header))
-        return true;
-
-    for (size_t i = 0; i < CURRENT_CRYPTO_REVISION; ++i) {
-        if (check_key_existence(S128KeyType::Master, i) ||
-            check_key_existence(S128KeyType::KeyArea, i,
-                                static_cast<u64>(KeyAreaKeyType::Application)) ||
-            check_key_existence(S128KeyType::KeyArea, i, static_cast<u64>(KeyAreaKeyType::Ocean)) ||
-            check_key_existence(S128KeyType::KeyArea, i,
-                                static_cast<u64>(KeyAreaKeyType::System)) ||
-            check_key_existence(S128KeyType::Titlekek, i))
-            return true;
-    }
-
-    return false;
-}
-
 bool KeyManager::HasKey(S128KeyType id, u64 field1, u64 field2) const {
     return s128_keys.find({id, field1, field2}) != s128_keys.end();
 }
@@ -535,30 +207,13 @@ Key256 KeyManager::GetKey(S256KeyType id, u64 field1, u64 field2) const {
     return s256_keys.at({id, field1, field2});
 }
 
-Key256 KeyManager::GetBISKey(u8 partition_id) const {
-    Key256 out{};
-
-    for (const auto& bis_type : {BISKeyType::Crypto, BISKeyType::Tweak}) {
-        if (HasKey(S128KeyType::BIS, partition_id, static_cast<u64>(bis_type))) {
-            std::memcpy(
-                out.data() + sizeof(Key128) * static_cast<u64>(bis_type),
-                s128_keys.at({S128KeyType::BIS, partition_id, static_cast<u64>(bis_type)}).data(),
-                sizeof(Key128));
-        }
-    }
-
-    return out;
-}
-
-template <size_t Size>
-void KeyManager::WriteKeyToFile(KeyCategory category, std::string_view keyname,
+template <std::size_t Size>
+void KeyManager::WriteKeyToFile(bool title_key, std::string_view keyname,
                                 const std::array<u8, Size>& key) {
     const std::string yuzu_keys_dir = FileUtil::GetUserPath(FileUtil::UserPath::KeysDir);
     std::string filename = "title.keys_autogenerated";
-    if (category == KeyCategory::Standard)
+    if (!title_key)
         filename = dev_mode ? "dev.keys_autogenerated" : "prod.keys_autogenerated";
-    else if (category == KeyCategory::Console)
-        filename = "console.keys_autogenerated";
     const auto add_info_text = !FileUtil::Exists(yuzu_keys_dir + DIR_SEP + filename);
     FileUtil::CreateFullPath(yuzu_keys_dir + DIR_SEP + filename);
     std::ofstream file(yuzu_keys_dir + DIR_SEP + filename, std::ios::app);
@@ -572,7 +227,7 @@ void KeyManager::WriteKeyToFile(KeyCategory category, std::string_view keyname,
     }
 
     file << fmt::format("\n{} = {}", keyname, Common::HexArrayToString(key));
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, filename, category == KeyCategory::Title);
+    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, filename, title_key);
 }
 
 void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
@@ -582,15 +237,8 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
         Key128 rights_id;
         std::memcpy(rights_id.data(), &field2, sizeof(u64));
         std::memcpy(rights_id.data() + sizeof(u64), &field1, sizeof(u64));
-        WriteKeyToFile(KeyCategory::Title, Common::HexArrayToString(rights_id), key);
+        WriteKeyToFile(true, Common::HexArrayToString(rights_id), key);
     }
-
-    auto category = KeyCategory::Standard;
-    if (id == S128KeyType::Keyblob || id == S128KeyType::KeyblobMAC || id == S128KeyType::TSEC ||
-        id == S128KeyType::SecureBoot || id == S128KeyType::SDSeed || id == S128KeyType::BIS) {
-        category = KeyCategory::Console;
-    }
-
     const auto iter2 = std::find_if(
         s128_file_id.begin(), s128_file_id.end(),
         [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S128KeyType>> elem) {
@@ -598,30 +246,7 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
                    std::tie(id, field1, field2);
         });
     if (iter2 != s128_file_id.end())
-        WriteKeyToFile(category, iter2->first, key);
-
-    // Variable cases
-    if (id == S128KeyType::KeyArea) {
-        static constexpr std::array<const char*, 3> kak_names = {"key_area_key_application_{:02X}",
-                                                                 "key_area_key_ocean_{:02X}",
-                                                                 "key_area_key_system_{:02X}"};
-        WriteKeyToFile(category, fmt::format(kak_names.at(field2), field1), key);
-    } else if (id == S128KeyType::Master) {
-        WriteKeyToFile(category, fmt::format("master_key_{:02X}", field1), key);
-    } else if (id == S128KeyType::Package1) {
-        WriteKeyToFile(category, fmt::format("package1_key_{:02X}", field1), key);
-    } else if (id == S128KeyType::Package2) {
-        WriteKeyToFile(category, fmt::format("package2_key_{:02X}", field1), key);
-    } else if (id == S128KeyType::Titlekek) {
-        WriteKeyToFile(category, fmt::format("titlekek_{:02X}", field1), key);
-    } else if (id == S128KeyType::Keyblob) {
-        WriteKeyToFile(category, fmt::format("keyblob_key_{:02X}", field1), key);
-    } else if (id == S128KeyType::KeyblobMAC) {
-        WriteKeyToFile(category, fmt::format("keyblob_mac_key_{:02X}", field1), key);
-    } else if (id == S128KeyType::Source && field1 == static_cast<u64>(SourceKeyType::Keyblob)) {
-        WriteKeyToFile(category, fmt::format("keyblob_key_source_{:02X}", field2), key);
-    }
-
+        WriteKeyToFile(false, iter2->first, key);
     s128_keys[{id, field1, field2}] = key;
 }
 
@@ -635,7 +260,7 @@ void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
                    std::tie(id, field1, field2);
         });
     if (iter != s256_file_id.end())
-        WriteKeyToFile(KeyCategory::Standard, iter->first, key);
+        WriteKeyToFile(false, iter->first, key);
     s256_keys[{id, field1, field2}] = key;
 }
 
@@ -665,388 +290,59 @@ void KeyManager::DeriveSDSeedLazy() {
         SetKey(S128KeyType::SDSeed, res.get());
 }
 
-static Key128 CalculateCMAC(const u8* source, size_t size, const Key128& key) {
-    Key128 out{};
-
-    mbedtls_cipher_cmac(mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_ECB), key.data(),
-                        key.size() * 8, source, size, out.data());
-    return out;
-}
-
-void KeyManager::DeriveBase() {
-    if (!BaseDeriveNecessary())
-        return;
-
-    if (!HasKey(S128KeyType::SecureBoot) || !HasKey(S128KeyType::TSEC))
-        return;
-
-    const auto has_bis = [this](u64 id) {
-        return HasKey(S128KeyType::BIS, id, static_cast<u64>(BISKeyType::Crypto)) &&
-               HasKey(S128KeyType::BIS, id, static_cast<u64>(BISKeyType::Tweak));
-    };
-
-    const auto copy_bis = [this](u64 id_from, u64 id_to) {
-        SetKey(S128KeyType::BIS,
-               GetKey(S128KeyType::BIS, id_from, static_cast<u64>(BISKeyType::Crypto)), id_to,
-               static_cast<u64>(BISKeyType::Crypto));
-
-        SetKey(S128KeyType::BIS,
-               GetKey(S128KeyType::BIS, id_from, static_cast<u64>(BISKeyType::Tweak)), id_to,
-               static_cast<u64>(BISKeyType::Tweak));
-    };
-
-    if (has_bis(2) && !has_bis(3))
-        copy_bis(2, 3);
-    else if (has_bis(3) && !has_bis(2))
-        copy_bis(3, 2);
-
-    std::bitset<32> revisions(0xFFFFFFFF);
-    for (size_t i = 0; i < revisions.size(); ++i) {
-        if (!HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::Keyblob), i) ||
-            encrypted_keyblobs[i] == std::array<u8, 0xB0>{}) {
-            revisions.reset(i);
-        }
-    }
-
-    if (!revisions.any())
-        return;
-
-    const auto sbk = GetKey(S128KeyType::SecureBoot);
-    const auto tsec = GetKey(S128KeyType::TSEC);
-    const auto master_source = GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::Master));
-
-    for (size_t i = 0; i < revisions.size(); ++i) {
-        if (!revisions[i])
-            continue;
-
-        // Derive keyblob key
-        const auto key = DeriveKeyblobKey(
-            sbk, tsec, GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::Keyblob), i));
-
-        SetKey(S128KeyType::Keyblob, key, i);
-
-        // Derive keyblob MAC key
-        if (!HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyblobMAC)))
-            continue;
-
-        const auto mac_key = DeriveKeyblobMACKey(
-            key, GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyblobMAC)));
-        SetKey(S128KeyType::KeyblobMAC, mac_key, i);
-
-        Key128 cmac = CalculateCMAC(encrypted_keyblobs[i].data() + 0x10, 0xA0, mac_key);
-        if (std::memcmp(cmac.data(), encrypted_keyblobs[i].data(), cmac.size()) != 0)
-            continue;
-
-        // Decrypt keyblob
-        if (keyblobs[i] == std::array<u8, 0x90>{}) {
-            keyblobs[i] = DecryptKeyblob(encrypted_keyblobs[i], key);
-            WriteKeyToFile<0x90>(KeyCategory::Console, fmt::format("keyblob_{:02X}", i),
-                                 keyblobs[i]);
-        }
-
-        Key128 package1;
-        std::memcpy(package1.data(), keyblobs[i].data() + 0x80, sizeof(Key128));
-        SetKey(S128KeyType::Package1, package1, i);
-
-        // Derive master key
-        if (HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::Master))) {
-            SetKey(S128KeyType::Master,
-                   DeriveMasterKey(keyblobs[i], GetKey(S128KeyType::Source,
-                                                       static_cast<u64>(SourceKeyType::Master))),
-                   i);
-        }
-    }
-
-    revisions.set();
-    for (size_t i = 0; i < revisions.size(); ++i) {
-        if (!HasKey(S128KeyType::Master, i))
-            revisions.reset(i);
-    }
-
-    if (!revisions.any())
-        return;
-
-    for (size_t i = 0; i < revisions.size(); ++i) {
-        if (!revisions[i])
-            continue;
-
-        // Derive general purpose keys
-        DeriveGeneralPurposeKeys(i);
-    }
-
-    if (HasKey(S128KeyType::Master, 0) &&
-        HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration)) &&
-        HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKekGeneration)) &&
-        HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::HeaderKek)) &&
-        HasKey(S256KeyType::HeaderSource)) {
-        const auto header_kek = GenerateKeyEncryptionKey(
-            GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::HeaderKek)),
-            GetKey(S128KeyType::Master, 0),
-            GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKekGeneration)),
-            GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration)));
-        SetKey(S128KeyType::HeaderKek, header_kek);
-
-        AESCipher<Key128> header_cipher(header_kek, Mode::ECB);
-        Key256 out = GetKey(S256KeyType::HeaderSource);
-        header_cipher.Transcode(out.data(), out.size(), out.data(), Op::Decrypt);
-        SetKey(S256KeyType::Header, out);
-    }
-}
-
-void KeyManager::DeriveETicket(PartitionDataManager& data) {
-    // ETicket keys
-    const auto es = Service::FileSystem::GetUnionContents()->GetEntry(
-        0x0100000000000033, FileSys::ContentRecordType::Program);
-
-    if (es == nullptr)
-        return;
-
-    const auto exefs = es->GetExeFS();
-    if (exefs == nullptr)
-        return;
-
-    const auto main = exefs->GetFile("main");
-    if (main == nullptr)
-        return;
-
-    const auto bytes = main->ReadAllBytes();
-
-    const auto eticket_kek = FindKeyFromHex16(bytes, eticket_source_hashes[0]);
-    const auto eticket_kekek = FindKeyFromHex16(bytes, eticket_source_hashes[1]);
-
-    const auto seed3 = data.GetRSAKekSeed3();
-    const auto mask0 = data.GetRSAKekMask0();
-
-    if (eticket_kek != Key128{})
-        SetKey(S128KeyType::Source, eticket_kek, static_cast<size_t>(SourceKeyType::ETicketKek));
-    if (eticket_kekek != Key128{}) {
-        SetKey(S128KeyType::Source, eticket_kekek,
-               static_cast<size_t>(SourceKeyType::ETicketKekek));
-    }
-    if (seed3 != Key128{})
-        SetKey(S128KeyType::RSAKek, seed3, static_cast<size_t>(RSAKekType::Seed3));
-    if (mask0 != Key128{})
-        SetKey(S128KeyType::RSAKek, mask0, static_cast<size_t>(RSAKekType::Mask0));
-    if (eticket_kek == Key128{} || eticket_kekek == Key128{} || seed3 == Key128{} ||
-        mask0 == Key128{}) {
-        return;
-    }
-
-    Key128 rsa_oaep_kek{};
-    std::transform(seed3.begin(), seed3.end(), mask0.begin(), rsa_oaep_kek.begin(),
-                   std::bit_xor<>());
-
-    if (rsa_oaep_kek == Key128{})
-        return;
-
-    SetKey(S128KeyType::Source, rsa_oaep_kek,
-           static_cast<u64>(SourceKeyType::RSAOaepKekGeneration));
-
-    Key128 temp_kek{};
-    Key128 temp_kekek{};
-    Key128 eticket_final{};
-
-    // Derive ETicket RSA Kek
-    AESCipher<Key128> es_master(GetKey(S128KeyType::Master), Mode::ECB);
-    es_master.Transcode(rsa_oaep_kek.data(), rsa_oaep_kek.size(), temp_kek.data(), Op::Decrypt);
-    AESCipher<Key128> es_kekek(temp_kek, Mode::ECB);
-    es_kekek.Transcode(eticket_kekek.data(), eticket_kekek.size(), temp_kekek.data(), Op::Decrypt);
-    AESCipher<Key128> es_kek(temp_kekek, Mode::ECB);
-    es_kek.Transcode(eticket_kek.data(), eticket_kek.size(), eticket_final.data(), Op::Decrypt);
-
-    if (eticket_final == Key128{})
-        return;
-
-    SetKey(S128KeyType::ETicketRSAKek, eticket_final);
-
-    // Titlekeys
-    data.DecryptProdInfo(GetBISKey(0));
-
-    const auto eticket_extended_kek = data.GetETicketExtendedKek();
-
-    std::vector<u8> extended_iv(0x10);
-    std::memcpy(extended_iv.data(), eticket_extended_kek.data(), extended_iv.size());
-    std::array<u8, 0x230> extended_dec{};
-    AESCipher<Key128> rsa_1(eticket_final, Mode::CTR);
-    rsa_1.SetIV(extended_iv);
-    rsa_1.Transcode(eticket_extended_kek.data() + 0x10, eticket_extended_kek.size() - 0x10,
-                    extended_dec.data(), Op::Decrypt);
-
-    RSAKeyPair<2048> rsa_key{};
-    std::memcpy(rsa_key.decryption_key.data(), extended_dec.data(), rsa_key.decryption_key.size());
-    std::memcpy(rsa_key.modulus.data(), extended_dec.data() + 0x100, rsa_key.modulus.size());
-    std::memcpy(rsa_key.exponent.data(), extended_dec.data() + 0x200, rsa_key.exponent.size());
-
-    const FileUtil::IOFile save1(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                                     "/system/save/80000000000000e1",
-                                 "rb+");
-    const FileUtil::IOFile save2(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                                     "/system/save/80000000000000e2",
-                                 "rb+");
-
-    const auto blob2 = GetTicketblob(save2);
-    auto res = GetTicketblob(save1);
-    res.insert(res.end(), blob2.begin(), blob2.end());
-
-    for (const auto& raw : res) {
-        const auto pair = ParseTicket(raw, rsa_key);
-        if (pair == boost::none)
-            continue;
-        const auto& [rid, key] = pair.value();
-        u128 rights_id;
-        std::memcpy(rights_id.data(), rid.data(), rid.size());
-        SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
-    }
-}
-
-void KeyManager::SetKeyWrapped(S128KeyType id, Key128 key, u64 field1, u64 field2) {
-    if (key == Key128{})
-        return;
-    SetKey(id, key, field1, field2);
-}
-
-void KeyManager::SetKeyWrapped(S256KeyType id, Key256 key, u64 field1, u64 field2) {
-    if (key == Key256{})
-        return;
-    SetKey(id, key, field1, field2);
-}
-
-void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) {
-    if (!BaseDeriveNecessary())
-        return;
-
-    if (!data.HasBoot0())
-        return;
-
-    for (size_t i = 0; i < encrypted_keyblobs.size(); ++i) {
-        if (encrypted_keyblobs[i] != std::array<u8, 0xB0>{})
-            continue;
-        encrypted_keyblobs[i] = data.GetEncryptedKeyblob(i);
-        WriteKeyToFile<0xB0>(KeyCategory::Console, fmt::format("encrypted_keyblob_{:02X}", i),
-                             encrypted_keyblobs[i]);
-    }
-
-    SetKeyWrapped(S128KeyType::Source, data.GetPackage2KeySource(),
-                  static_cast<u64>(SourceKeyType::Package2));
-    SetKeyWrapped(S128KeyType::Source, data.GetAESKekGenerationSource(),
-                  static_cast<u64>(SourceKeyType::AESKekGeneration));
-    SetKeyWrapped(S128KeyType::Source, data.GetTitlekekSource(),
-                  static_cast<u64>(SourceKeyType::Titlekek));
-    SetKeyWrapped(S128KeyType::Source, data.GetMasterKeySource(),
-                  static_cast<u64>(SourceKeyType::Master));
-    SetKeyWrapped(S128KeyType::Source, data.GetKeyblobMACKeySource(),
-                  static_cast<u64>(SourceKeyType::KeyblobMAC));
-
-    for (size_t i = 0; i < PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH; ++i) {
-        SetKeyWrapped(S128KeyType::Source, data.GetKeyblobKeySource(i),
-                      static_cast<u64>(SourceKeyType::Keyblob), i);
-    }
-
-    if (data.HasFuses())
-        SetKeyWrapped(S128KeyType::SecureBoot, data.GetSecureBootKey());
-
-    DeriveBase();
-
-    Key128 latest_master{};
-    for (s8 i = 0x1F; i >= 0; --i) {
-        if (GetKey(S128KeyType::Master, static_cast<u8>(i)) != Key128{}) {
-            latest_master = GetKey(S128KeyType::Master, static_cast<u8>(i));
-            break;
-        }
-    }
-
-    const auto masters = data.GetTZMasterKeys(latest_master);
-    for (size_t i = 0; i < masters.size(); ++i) {
-        if (masters[i] != Key128{} && !HasKey(S128KeyType::Master, i))
-            SetKey(S128KeyType::Master, masters[i], i);
-    }
-
-    DeriveBase();
-
-    if (!data.HasPackage2())
-        return;
-
-    std::array<Key128, 0x20> package2_keys{};
-    for (size_t i = 0; i < package2_keys.size(); ++i) {
-        if (HasKey(S128KeyType::Package2, i))
-            package2_keys[i] = GetKey(S128KeyType::Package2, i);
-    }
-    data.DecryptPackage2(package2_keys, Package2Type::NormalMain);
-
-    SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeyApplicationSource(),
-                  static_cast<u64>(SourceKeyType::KeyAreaKey),
-                  static_cast<u64>(KeyAreaKeyType::Application));
-    SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeyOceanSource(),
-                  static_cast<u64>(SourceKeyType::KeyAreaKey),
-                  static_cast<u64>(KeyAreaKeyType::Ocean));
-    SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeySystemSource(),
-                  static_cast<u64>(SourceKeyType::KeyAreaKey),
-                  static_cast<u64>(KeyAreaKeyType::System));
-    SetKeyWrapped(S128KeyType::Source, data.GetSDKekSource(),
-                  static_cast<u64>(SourceKeyType::SDKek));
-    SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDSaveKeySource(),
-                  static_cast<u64>(SDKeyType::Save));
-    SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDNCAKeySource(),
-                  static_cast<u64>(SDKeyType::NCA));
-    SetKeyWrapped(S128KeyType::Source, data.GetHeaderKekSource(),
-                  static_cast<u64>(SourceKeyType::HeaderKek));
-    SetKeyWrapped(S256KeyType::HeaderSource, data.GetHeaderKeySource());
-    SetKeyWrapped(S128KeyType::Source, data.GetAESKeyGenerationSource(),
-                  static_cast<u64>(SourceKeyType::AESKeyGeneration));
-
-    DeriveBase();
-}
-
 const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager::s128_file_id = {
+    {"master_key_00", {S128KeyType::Master, 0, 0}},
+    {"master_key_01", {S128KeyType::Master, 1, 0}},
+    {"master_key_02", {S128KeyType::Master, 2, 0}},
+    {"master_key_03", {S128KeyType::Master, 3, 0}},
+    {"master_key_04", {S128KeyType::Master, 4, 0}},
+    {"package1_key_00", {S128KeyType::Package1, 0, 0}},
+    {"package1_key_01", {S128KeyType::Package1, 1, 0}},
+    {"package1_key_02", {S128KeyType::Package1, 2, 0}},
+    {"package1_key_03", {S128KeyType::Package1, 3, 0}},
+    {"package1_key_04", {S128KeyType::Package1, 4, 0}},
+    {"package2_key_00", {S128KeyType::Package2, 0, 0}},
+    {"package2_key_01", {S128KeyType::Package2, 1, 0}},
+    {"package2_key_02", {S128KeyType::Package2, 2, 0}},
+    {"package2_key_03", {S128KeyType::Package2, 3, 0}},
+    {"package2_key_04", {S128KeyType::Package2, 4, 0}},
+    {"titlekek_00", {S128KeyType::Titlekek, 0, 0}},
+    {"titlekek_01", {S128KeyType::Titlekek, 1, 0}},
+    {"titlekek_02", {S128KeyType::Titlekek, 2, 0}},
+    {"titlekek_03", {S128KeyType::Titlekek, 3, 0}},
+    {"titlekek_04", {S128KeyType::Titlekek, 4, 0}},
     {"eticket_rsa_kek", {S128KeyType::ETicketRSAKek, 0, 0}},
-    {"eticket_rsa_kek_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::ETicketKek), 0}},
-    {"eticket_rsa_kekek_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::ETicketKekek), 0}},
-    {"rsa_kek_mask_0", {S128KeyType::RSAKek, static_cast<u64>(RSAKekType::Mask0), 0}},
-    {"rsa_kek_seed_3", {S128KeyType::RSAKek, static_cast<u64>(RSAKekType::Seed3), 0}},
-    {"rsa_oaep_kek_generation_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::RSAOaepKekGeneration), 0}},
-    {"sd_card_kek_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKek), 0}},
+    {"key_area_key_application_00",
+     {S128KeyType::KeyArea, 0, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_01",
+     {S128KeyType::KeyArea, 1, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_02",
+     {S128KeyType::KeyArea, 2, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_03",
+     {S128KeyType::KeyArea, 3, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_application_04",
+     {S128KeyType::KeyArea, 4, static_cast<u64>(KeyAreaKeyType::Application)}},
+    {"key_area_key_ocean_00", {S128KeyType::KeyArea, 0, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_01", {S128KeyType::KeyArea, 1, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_02", {S128KeyType::KeyArea, 2, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_03", {S128KeyType::KeyArea, 3, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_ocean_04", {S128KeyType::KeyArea, 4, static_cast<u64>(KeyAreaKeyType::Ocean)}},
+    {"key_area_key_system_00", {S128KeyType::KeyArea, 0, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_01", {S128KeyType::KeyArea, 1, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_02", {S128KeyType::KeyArea, 2, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_03", {S128KeyType::KeyArea, 3, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"key_area_key_system_04", {S128KeyType::KeyArea, 4, static_cast<u64>(KeyAreaKeyType::System)}},
+    {"sd_card_kek_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKEK), 0}},
     {"aes_kek_generation_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKekGeneration), 0}},
+     {S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKEKGeneration), 0}},
     {"aes_key_generation_source",
      {S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration), 0}},
-    {"package2_key_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::Package2), 0}},
-    {"master_key_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::Master), 0}},
-    {"header_kek_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::HeaderKek), 0}},
-    {"key_area_key_application_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyAreaKey),
-      static_cast<u64>(KeyAreaKeyType::Application)}},
-    {"key_area_key_ocean_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyAreaKey),
-      static_cast<u64>(KeyAreaKeyType::Ocean)}},
-    {"key_area_key_system_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyAreaKey),
-      static_cast<u64>(KeyAreaKeyType::System)}},
-    {"titlekek_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::Titlekek), 0}},
-    {"keyblob_mac_key_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::KeyblobMAC)}},
-    {"tsec_key", {S128KeyType::TSEC, 0, 0}},
-    {"secure_boot_key", {S128KeyType::SecureBoot, 0, 0}},
     {"sd_seed", {S128KeyType::SDSeed, 0, 0}},
-    {"bis_key_0_crypt", {S128KeyType::BIS, 0, static_cast<u64>(BISKeyType::Crypto)}},
-    {"bis_key_0_tweak", {S128KeyType::BIS, 0, static_cast<u64>(BISKeyType::Tweak)}},
-    {"bis_key_1_crypt", {S128KeyType::BIS, 1, static_cast<u64>(BISKeyType::Crypto)}},
-    {"bis_key_1_tweak", {S128KeyType::BIS, 1, static_cast<u64>(BISKeyType::Tweak)}},
-    {"bis_key_2_crypt", {S128KeyType::BIS, 2, static_cast<u64>(BISKeyType::Crypto)}},
-    {"bis_key_2_tweak", {S128KeyType::BIS, 2, static_cast<u64>(BISKeyType::Tweak)}},
-    {"bis_key_3_crypt", {S128KeyType::BIS, 3, static_cast<u64>(BISKeyType::Crypto)}},
-    {"bis_key_3_tweak", {S128KeyType::BIS, 3, static_cast<u64>(BISKeyType::Tweak)}},
-    {"header_kek", {S128KeyType::HeaderKek, 0, 0}},
-    {"sd_card_kek", {S128KeyType::SDKek, 0, 0}},
 };
 
 const boost::container::flat_map<std::string, KeyIndex<S256KeyType>> KeyManager::s256_file_id = {
     {"header_key", {S256KeyType::Header, 0, 0}},
     {"sd_card_save_key_source", {S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::Save), 0}},
     {"sd_card_nca_key_source", {S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::NCA), 0}},
-    {"header_key_source", {S256KeyType::HeaderSource, 0, 0}},
-    {"sd_card_save_key", {S256KeyType::SDKey, static_cast<u64>(SDKeyType::Save), 0}},
-    {"sd_card_nca_key", {S256KeyType::SDKey, static_cast<u64>(SDKeyType::NCA), 0}},
 };
 } // namespace Core::Crypto

src/core/crypto/key_manager.h

@@ -5,18 +5,11 @@
 #pragma once
 
 #include <array>
-#include <map>
 #include <string>
 #include <boost/container/flat_map.hpp>
 #include <boost/optional.hpp>
 #include <fmt/format.h>
 #include "common/common_types.h"
-#include "core/crypto/partition_data_manager.h"
-#include "core/file_sys/vfs_types.h"
-
-namespace FileUtil {
-class IOFile;
-}
 
 namespace Loader {
 enum class ResultStatus : u16;
@@ -29,30 +22,13 @@ constexpr u64 TICKET_FILE_TITLEKEY_OFFSET = 0x180;
 using Key128 = std::array<u8, 0x10>;
 using Key256 = std::array<u8, 0x20>;
 using SHA256Hash = std::array<u8, 0x20>;
-using TicketRaw = std::array<u8, 0x400>;
 
 static_assert(sizeof(Key128) == 16, "Key128 must be 128 bytes big.");
-static_assert(sizeof(Key256) == 32, "Key256 must be 256 bytes big.");
-
-template <size_t bit_size, size_t byte_size = (bit_size >> 3)>
-struct RSAKeyPair {
-    std::array<u8, byte_size> encryption_key;
-    std::array<u8, byte_size> decryption_key;
-    std::array<u8, byte_size> modulus;
-    std::array<u8, 4> exponent;
-};
-
-enum class KeyCategory : u8 {
-    Standard,
-    Title,
-    Console,
-};
+static_assert(sizeof(Key256) == 32, "Key128 must be 128 bytes big.");
 
 enum class S256KeyType : u64 {
-    SDKey,        // f1=SDKeyType
-    Header,       //
-    SDKeySource,  // f1=SDKeyType
-    HeaderSource, //
+    Header,      //
+    SDKeySource, // f1=SDKeyType
 };
 
 enum class S128KeyType : u64 {
@@ -65,14 +41,6 @@ enum class S128KeyType : u64 {
     SDSeed,        //
     Titlekey,      // f1=rights id LSB f2=rights id MSB
     Source,        // f1=source type, f2= sub id
-    Keyblob,       // f1=crypto revision
-    KeyblobMAC,    // f1=crypto revision
-    TSEC,          //
-    SecureBoot,    //
-    BIS,           // f1=partition (0-3), f2=type {crypt, tweak}
-    HeaderKek,     //
-    SDKek,         //
-    RSAKek,        //
 };
 
 enum class KeyAreaKeyType : u8 {
@@ -82,19 +50,9 @@ enum class KeyAreaKeyType : u8 {
 };
 
 enum class SourceKeyType : u8 {
-    SDKek,                //
-    AESKekGeneration,     //
-    AESKeyGeneration,     //
-    RSAOaepKekGeneration, //
-    Master,               //
-    Keyblob,              // f2=crypto revision
-    KeyAreaKey,           // f2=KeyAreaKeyType
-    Titlekek,             //
-    Package2,             //
-    HeaderKek,            //
-    KeyblobMAC,           //
-    ETicketKek,           //
-    ETicketKekek,         //
+    SDKEK,
+    AESKEKGeneration,
+    AESKeyGeneration,
 };
 
 enum class SDKeyType : u8 {
@@ -102,16 +60,6 @@ enum class SDKeyType : u8 {
     NCA,
 };
 
-enum class BISKeyType : u8 {
-    Crypto,
-    Tweak,
-};
-
-enum class RSAKekType : u8 {
-    Mask0,
-    Seed3,
-};
-
 template <typename KeyType>
 struct KeyIndex {
     KeyType type;
@@ -143,8 +91,6 @@ public:
     Key128 GetKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0) const;
     Key256 GetKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0) const;
 
-    Key256 GetBISKey(u8 partition_id) const;
-
     void SetKey(S128KeyType id, Key128 key, u64 field1 = 0, u64 field2 = 0);
     void SetKey(S256KeyType id, Key256 key, u64 field1 = 0, u64 field2 = 0);
 
@@ -154,51 +100,23 @@ public:
     // 8*43 and the private file to exist.
     void DeriveSDSeedLazy();
 
-    bool BaseDeriveNecessary() const;
-    void DeriveBase();
-    void DeriveETicket(PartitionDataManager& data);
-
-    void PopulateFromPartitionData(PartitionDataManager& data);
-
 private:
-    std::map<KeyIndex<S128KeyType>, Key128> s128_keys;
-    std::map<KeyIndex<S256KeyType>, Key256> s256_keys;
-
-    std::array<std::array<u8, 0xB0>, 0x20> encrypted_keyblobs{};
-    std::array<std::array<u8, 0x90>, 0x20> keyblobs{};
+    boost::container::flat_map<KeyIndex<S128KeyType>, Key128> s128_keys;
+    boost::container::flat_map<KeyIndex<S256KeyType>, Key256> s256_keys;
 
     bool dev_mode;
     void LoadFromFile(const std::string& filename, bool is_title_keys);
     void AttemptLoadKeyFile(const std::string& dir1, const std::string& dir2,
                             const std::string& filename, bool title);
-    template <size_t Size>
-    void WriteKeyToFile(KeyCategory category, std::string_view keyname,
-                        const std::array<u8, Size>& key);
-
-    void DeriveGeneralPurposeKeys(std::size_t crypto_revision);
-
-    void SetKeyWrapped(S128KeyType id, Key128 key, u64 field1 = 0, u64 field2 = 0);
-    void SetKeyWrapped(S256KeyType id, Key256 key, u64 field1 = 0, u64 field2 = 0);
+    template <std::size_t Size>
+    void WriteKeyToFile(bool title_key, std::string_view keyname, const std::array<u8, Size>& key);
 
     static const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> s128_file_id;
     static const boost::container::flat_map<std::string, KeyIndex<S256KeyType>> s256_file_id;
 };
 
 Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed);
-Key128 DeriveKeyblobKey(const Key128& sbk, const Key128& tsec, Key128 source);
-Key128 DeriveKeyblobMACKey(const Key128& keyblob_key, const Key128& mac_source);
-Key128 DeriveMasterKey(const std::array<u8, 0x90>& keyblob, const Key128& master_source);
-std::array<u8, 0x90> DecryptKeyblob(const std::array<u8, 0xB0>& encrypted_keyblob,
-                                    const Key128& key);
-
 boost::optional<Key128> DeriveSDSeed();
-Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& keys);
-
-std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save);
-
-// Returns a pair of {rights_id, titlekey}. Fails if the ticket has no certificate authority (offset
-// 0x140-0x144 is zero)
-boost::optional<std::pair<Key128, Key128>> ParseTicket(
-    const TicketRaw& ticket, const RSAKeyPair<2048>& eticket_extended_key);
+Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, const KeyManager& keys);
 
 } // namespace Core::Crypto

src/core/crypto/partition_data_manager.cpp

@@ -1,594 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// NOTE TO FUTURE MAINTAINERS:
-// When a new version of switch cryptography is released,
-// hash the new keyblob source and master key and add the hashes to
-// the arrays below.
-
-#include <algorithm>
-#include <array>
-#include <cctype>
-#include <cstring>
-#include <mbedtls/sha256.h>
-#include "common/assert.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/hex_util.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "common/swap.h"
-#include "core/crypto/key_manager.h"
-#include "core/crypto/partition_data_manager.h"
-#include "core/crypto/xts_encryption_layer.h"
-#include "core/file_sys/vfs.h"
-#include "core/file_sys/vfs_offset.h"
-
-using namespace Common;
-
-namespace Core::Crypto {
-
-struct Package2Header {
-    std::array<u8, 0x100> signature;
-    Key128 header_ctr;
-    std::array<Key128, 4> section_ctr;
-    u32_le magic;
-    u32_le base_offset;
-    INSERT_PADDING_BYTES(4);
-    u8 version_max;
-    u8 version_min;
-    INSERT_PADDING_BYTES(2);
-    std::array<u32_le, 4> section_size;
-    std::array<u32_le, 4> section_offset;
-    std::array<SHA256Hash, 4> section_hash;
-};
-static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect size.");
-
-struct INIHeader {
-    u32_le magic;
-    u32_le size;
-    u32_le process_count;
-    INSERT_PADDING_BYTES(4);
-};
-static_assert(sizeof(INIHeader) == 0x10, "INIHeader has incorrect size.");
-
-struct SectionHeader {
-    u32_le offset;
-    u32_le size_decompressed;
-    u32_le size_compressed;
-    u32_le attribute;
-};
-static_assert(sizeof(SectionHeader) == 0x10, "SectionHeader has incorrect size.");
-
-struct KIPHeader {
-    u32_le magic;
-    std::array<char, 12> name;
-    u64_le title_id;
-    u32_le category;
-    u8 priority;
-    u8 core;
-    INSERT_PADDING_BYTES(1);
-    u8 flags;
-    std::array<SectionHeader, 6> sections;
-    std::array<u32, 0x20> capabilities;
-};
-static_assert(sizeof(KIPHeader) == 0x100, "KIPHeader has incorrect size.");
-
-const std::array<SHA256Hash, 0x10> source_hashes{
-    "B24BD293259DBC7AC5D63F88E60C59792498E6FC5443402C7FFE87EE8B61A3F0"_array32, // keyblob_mac_key_source
-    "7944862A3A5C31C6720595EFD302245ABD1B54CCDCF33000557681E65C5664A4"_array32, // master_key_source
-    "21E2DF100FC9E094DB51B47B9B1D6E94ED379DB8B547955BEF8FE08D8DD35603"_array32, // package2_key_source
-    "FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"_array32, // aes_kek_generation_source
-    "FBD10056999EDC7ACDB96098E47E2C3606230270D23281E671F0F389FC5BC585"_array32, // aes_key_generation_source
-    "C48B619827986C7F4E3081D59DB2B460C84312650E9A8E6B458E53E8CBCA4E87"_array32, // titlekek_source
-    "04AD66143C726B2A139FB6B21128B46F56C553B2B3887110304298D8D0092D9E"_array32, // key_area_key_application_source
-    "FD434000C8FF2B26F8E9A9D2D2C12F6BE5773CBB9DC86300E1BD99F8EA33A417"_array32, // key_area_key_ocean_source
-    "1F17B1FD51AD1C2379B58F152CA4912EC2106441E51722F38700D5937A1162F7"_array32, // key_area_key_system_source
-    "6B2ED877C2C52334AC51E59ABFA7EC457F4A7D01E46291E9F2EAA45F011D24B7"_array32, // sd_card_kek_source
-    "D482743563D3EA5DCDC3B74E97C9AC8A342164FA041A1DC80F17F6D31E4BC01C"_array32, // sd_card_save_key_source
-    "2E751CECF7D93A2B957BD5FFCB082FD038CC2853219DD3092C6DAB9838F5A7CC"_array32, // sd_card_nca_key_source
-    "1888CAED5551B3EDE01499E87CE0D86827F80820EFB275921055AA4E2ABDFFC2"_array32, // header_kek_source
-    "8F783E46852DF6BE0BA4E19273C4ADBAEE16380043E1B8C418C4089A8BD64AA6"_array32, // header_key_source
-    "D1757E52F1AE55FA882EC690BC6F954AC46A83DC22F277F8806BD55577C6EED7"_array32, // rsa_kek_seed3
-    "FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"_array32, // rsa_kek_mask0
-};
-
-const std::array<SHA256Hash, 0x20> keyblob_source_hashes{
-    "8A06FE274AC491436791FDB388BCDD3AB9943BD4DEF8094418CDAC150FD73786"_array32, // keyblob_key_source_00
-    "2D5CAEB2521FEF70B47E17D6D0F11F8CE2C1E442A979AD8035832C4E9FBCCC4B"_array32, // keyblob_key_source_01
-    "61C5005E713BAE780641683AF43E5F5C0E03671117F702F401282847D2FC6064"_array32, // keyblob_key_source_02
-    "8E9795928E1C4428E1B78F0BE724D7294D6934689C11B190943923B9D5B85903"_array32, // keyblob_key_source_03
-    "95FA33AF95AFF9D9B61D164655B32710ED8D615D46C7D6CC3CC70481B686B402"_array32, // keyblob_key_source_04
-    "3F5BE7B3C8B1ABD8C10B4B703D44766BA08730562C172A4FE0D6B866B3E2DB3E"_array32, // keyblob_key_source_05
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_06
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_07
-
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_08
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_09
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0D
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0E
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_0F
-
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_10
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_11
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_12
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_13
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_14
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_15
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_16
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_17
-
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_18
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_19
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1D
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1E
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // keyblob_key_source_1F
-};
-
-const std::array<SHA256Hash, 0x20> master_key_hashes{
-    "0EE359BE3C864BB0782E1D70A718A0342C551EED28C369754F9C4F691BECF7CA"_array32, // master_key_00
-    "4FE707B7E4ABDAF727C894AAF13B1351BFE2AC90D875F73B2E20FA94B9CC661E"_array32, // master_key_01
-    "79277C0237A2252EC3DFAC1F7C359C2B3D121E9DB15BB9AB4C2B4408D2F3AE09"_array32, // master_key_02
-    "4F36C565D13325F65EE134073C6A578FFCB0008E02D69400836844EAB7432754"_array32, // master_key_03
-    "75FF1D95D26113550EE6FCC20ACB58E97EDEB3A2FF52543ED5AEC63BDCC3DA50"_array32, // master_key_04
-    "EBE2BCD6704673EC0F88A187BB2AD9F1CC82B718C389425941BDC194DC46B0DD"_array32, // master_key_05
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_06
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_07
-
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_08
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_09
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0D
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0E
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_0F
-
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_10
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_11
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_12
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_13
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_14
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_15
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_16
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_17
-
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_18
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_19
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1A
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1B
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1C
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1D
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1E
-    "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1F
-};
-
-static std::vector<u8> DecompressBLZ(const std::vector<u8>& in) {
-    const auto data_size = in.size() - 0xC;
-
-    u32 compressed_size{};
-    u32 init_index{};
-    u32 additional_size{};
-    std::memcpy(&compressed_size, in.data() + data_size, sizeof(u32));
-    std::memcpy(&init_index, in.data() + data_size + 0x4, sizeof(u32));
-    std::memcpy(&additional_size, in.data() + data_size + 0x8, sizeof(u32));
-
-    std::vector<u8> out(in.size() + additional_size);
-
-    if (compressed_size == in.size())
-        std::memcpy(out.data(), in.data() + in.size() - compressed_size, compressed_size);
-    else
-        std::memcpy(out.data(), in.data(), compressed_size);
-
-    auto index = in.size() - init_index;
-    auto out_index = out.size();
-
-    while (out_index > 0) {
-        --index;
-        auto control = in[index];
-        for (size_t i = 0; i < 8; ++i) {
-            if ((control & 0x80) > 0) {
-                ASSERT(index >= 2);
-                index -= 2;
-                u64 segment_offset = in[index] | in[index + 1] << 8;
-                u64 segment_size = ((segment_offset >> 12) & 0xF) + 3;
-                segment_offset &= 0xFFF;
-                segment_offset += 3;
-
-                if (out_index < segment_size)
-                    segment_size = out_index;
-
-                ASSERT(out_index >= segment_size);
-
-                out_index -= segment_size;
-
-                for (size_t j = 0; j < segment_size; ++j) {
-                    ASSERT(out_index + j + segment_offset < out.size());
-                    out[out_index + j] = out[out_index + j + segment_offset];
-                }
-            } else {
-                ASSERT(out_index >= 1);
-                --out_index;
-                --index;
-                out[out_index] = in[index];
-            }
-
-            control <<= 1;
-            if (out_index == 0)
-                return out;
-        }
-    }
-
-    return out;
-}
-
-static u8 CalculateMaxKeyblobSourceHash() {
-    for (s8 i = 0x1F; i >= 0; --i) {
-        if (keyblob_source_hashes[i] != SHA256Hash{})
-            return static_cast<u8>(i + 1);
-    }
-
-    return 0;
-}
-
-const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = CalculateMaxKeyblobSourceHash();
-
-template <size_t key_size = 0x10>
-std::array<u8, key_size> FindKeyFromHex(const std::vector<u8>& binary,
-                                        const std::array<u8, 0x20>& hash) {
-    if (binary.size() < key_size)
-        return {};
-
-    std::array<u8, 0x20> temp{};
-    for (size_t i = 0; i < binary.size() - key_size; ++i) {
-        mbedtls_sha256(binary.data() + i, key_size, temp.data(), 0);
-
-        if (temp != hash)
-            continue;
-
-        std::array<u8, key_size> out{};
-        std::memcpy(out.data(), binary.data() + i, key_size);
-        return out;
-    }
-
-    return {};
-}
-
-std::array<u8, 16> FindKeyFromHex16(const std::vector<u8>& binary, std::array<u8, 32> hash) {
-    return FindKeyFromHex<0x10>(binary, hash);
-}
-
-static std::array<Key128, 0x20> FindEncryptedMasterKeyFromHex(const std::vector<u8>& binary,
-                                                              const Key128& key) {
-    if (binary.size() < 0x10)
-        return {};
-
-    SHA256Hash temp{};
-    Key128 dec_temp{};
-    std::array<Key128, 0x20> out{};
-    AESCipher<Key128> cipher(key, Mode::ECB);
-    for (size_t i = 0; i < binary.size() - 0x10; ++i) {
-        cipher.Transcode(binary.data() + i, dec_temp.size(), dec_temp.data(), Op::Decrypt);
-        mbedtls_sha256(dec_temp.data(), dec_temp.size(), temp.data(), 0);
-
-        for (size_t k = 0; k < out.size(); ++k) {
-            if (temp == master_key_hashes[k]) {
-                out[k] = dec_temp;
-                break;
-            }
-        }
-    }
-
-    return out;
-}
-
-FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir,
-                                            const std::string& name) {
-    auto upper = name;
-    std::transform(upper.begin(), upper.end(), upper.begin(), [](u8 c) { return std::toupper(c); });
-    for (const auto& fname : {name, name + ".bin", upper, upper + ".BIN"}) {
-        if (dir->GetFile(fname) != nullptr)
-            return dir->GetFile(fname);
-    }
-
-    return nullptr;
-}
-
-PartitionDataManager::PartitionDataManager(const FileSys::VirtualDir& sysdata_dir)
-    : boot0(FindFileInDirWithNames(sysdata_dir, "BOOT0")),
-      fuses(FindFileInDirWithNames(sysdata_dir, "fuses")),
-      kfuses(FindFileInDirWithNames(sysdata_dir, "kfuses")),
-      package2({
-          FindFileInDirWithNames(sysdata_dir, "BCPKG2-1-Normal-Main"),
-          FindFileInDirWithNames(sysdata_dir, "BCPKG2-2-Normal-Sub"),
-          FindFileInDirWithNames(sysdata_dir, "BCPKG2-3-SafeMode-Main"),
-          FindFileInDirWithNames(sysdata_dir, "BCPKG2-4-SafeMode-Sub"),
-          FindFileInDirWithNames(sysdata_dir, "BCPKG2-5-Repair-Main"),
-          FindFileInDirWithNames(sysdata_dir, "BCPKG2-6-Repair-Sub"),
-      }),
-      prodinfo(FindFileInDirWithNames(sysdata_dir, "PRODINFO")),
-      secure_monitor(FindFileInDirWithNames(sysdata_dir, "secmon")),
-      package1_decrypted(FindFileInDirWithNames(sysdata_dir, "pkg1_decr")),
-      secure_monitor_bytes(secure_monitor == nullptr ? std::vector<u8>{}
-                                                     : secure_monitor->ReadAllBytes()),
-      package1_decrypted_bytes(package1_decrypted == nullptr ? std::vector<u8>{}
-                                                             : package1_decrypted->ReadAllBytes()) {
-}
-
-PartitionDataManager::~PartitionDataManager() = default;
-
-bool PartitionDataManager::HasBoot0() const {
-    return boot0 != nullptr;
-}
-
-FileSys::VirtualFile PartitionDataManager::GetBoot0Raw() const {
-    return boot0;
-}
-
-PartitionDataManager::EncryptedKeyBlob PartitionDataManager::GetEncryptedKeyblob(
-    std::size_t index) const {
-    if (HasBoot0() && index < NUM_ENCRYPTED_KEYBLOBS)
-        return GetEncryptedKeyblobs()[index];
-    return {};
-}
-
-PartitionDataManager::EncryptedKeyBlobs PartitionDataManager::GetEncryptedKeyblobs() const {
-    if (!HasBoot0())
-        return {};
-
-    EncryptedKeyBlobs out{};
-    for (size_t i = 0; i < out.size(); ++i)
-        boot0->Read(out[i].data(), out[i].size(), 0x180000 + i * 0x200);
-    return out;
-}
-
-std::vector<u8> PartitionDataManager::GetSecureMonitor() const {
-    return secure_monitor_bytes;
-}
-
-std::array<u8, 16> PartitionDataManager::GetPackage2KeySource() const {
-    return FindKeyFromHex(secure_monitor_bytes, source_hashes[2]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetAESKekGenerationSource() const {
-    return FindKeyFromHex(secure_monitor_bytes, source_hashes[3]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetTitlekekSource() const {
-    return FindKeyFromHex(secure_monitor_bytes, source_hashes[5]);
-}
-
-std::array<std::array<u8, 16>, 32> PartitionDataManager::GetTZMasterKeys(
-    std::array<u8, 0x10> master_key) const {
-    return FindEncryptedMasterKeyFromHex(secure_monitor_bytes, master_key);
-}
-
-std::array<u8, 16> PartitionDataManager::GetRSAKekSeed3() const {
-    return FindKeyFromHex(secure_monitor_bytes, source_hashes[14]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetRSAKekMask0() const {
-    return FindKeyFromHex(secure_monitor_bytes, source_hashes[15]);
-}
-
-std::vector<u8> PartitionDataManager::GetPackage1Decrypted() const {
-    return package1_decrypted_bytes;
-}
-
-std::array<u8, 16> PartitionDataManager::GetMasterKeySource() const {
-    return FindKeyFromHex(package1_decrypted_bytes, source_hashes[1]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetKeyblobMACKeySource() const {
-    return FindKeyFromHex(package1_decrypted_bytes, source_hashes[0]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetKeyblobKeySource(std::size_t revision) const {
-    if (keyblob_source_hashes[revision] == SHA256Hash{}) {
-        LOG_WARNING(Crypto,
-                    "No keyblob source hash for crypto revision {:02X}! Cannot derive keys...",
-                    revision);
-    }
-    return FindKeyFromHex(package1_decrypted_bytes, keyblob_source_hashes[revision]);
-}
-
-bool PartitionDataManager::HasFuses() const {
-    return fuses != nullptr;
-}
-
-FileSys::VirtualFile PartitionDataManager::GetFusesRaw() const {
-    return fuses;
-}
-
-std::array<u8, 16> PartitionDataManager::GetSecureBootKey() const {
-    if (!HasFuses())
-        return {};
-    Key128 out{};
-    fuses->Read(out.data(), out.size(), 0xA4);
-    return out;
-}
-
-bool PartitionDataManager::HasKFuses() const {
-    return kfuses != nullptr;
-}
-
-FileSys::VirtualFile PartitionDataManager::GetKFusesRaw() const {
-    return kfuses;
-}
-
-bool PartitionDataManager::HasPackage2(Package2Type type) const {
-    return package2.at(static_cast<size_t>(type)) != nullptr;
-}
-
-FileSys::VirtualFile PartitionDataManager::GetPackage2Raw(Package2Type type) const {
-    return package2.at(static_cast<size_t>(type));
-}
-
-bool AttemptDecrypt(const std::array<u8, 16>& key, Package2Header& header) {
-
-    const std::vector<u8> iv(header.header_ctr.begin(), header.header_ctr.end());
-    Package2Header temp = header;
-    AESCipher<Key128> cipher(key, Mode::CTR);
-    cipher.SetIV(iv);
-    cipher.Transcode(&temp.header_ctr, sizeof(Package2Header) - 0x100, &temp.header_ctr,
-                     Op::Decrypt);
-    if (temp.magic == Common::MakeMagic('P', 'K', '2', '1')) {
-        header = temp;
-        return true;
-    }
-
-    return false;
-}
-
-void PartitionDataManager::DecryptPackage2(const std::array<Key128, 0x20>& package2_keys,
-                                           Package2Type type) {
-    FileSys::VirtualFile file = std::make_shared<FileSys::OffsetVfsFile>(
-        package2[static_cast<size_t>(type)],
-        package2[static_cast<size_t>(type)]->GetSize() - 0x4000, 0x4000);
-
-    Package2Header header{};
-    if (file->ReadObject(&header) != sizeof(Package2Header))
-        return;
-
-    std::size_t revision = 0xFF;
-    if (header.magic != Common::MakeMagic('P', 'K', '2', '1')) {
-        for (std::size_t i = 0; i < package2_keys.size(); ++i) {
-            if (AttemptDecrypt(package2_keys[i], header)) {
-                revision = i;
-            }
-        }
-    }
-
-    if (header.magic != Common::MakeMagic('P', 'K', '2', '1'))
-        return;
-
-    const auto a = std::make_shared<FileSys::OffsetVfsFile>(
-        file, header.section_size[1], header.section_size[0] + sizeof(Package2Header));
-
-    auto c = a->ReadAllBytes();
-
-    AESCipher<Key128> cipher(package2_keys[revision], Mode::CTR);
-    cipher.SetIV({header.section_ctr[1].begin(), header.section_ctr[1].end()});
-    cipher.Transcode(c.data(), c.size(), c.data(), Op::Decrypt);
-
-    INIHeader ini;
-    std::memcpy(&ini, c.data(), sizeof(INIHeader));
-    if (ini.magic != Common::MakeMagic('I', 'N', 'I', '1'))
-        return;
-
-    u64 offset = sizeof(INIHeader);
-    for (size_t i = 0; i < ini.process_count; ++i) {
-        KIPHeader kip;
-        std::memcpy(&kip, c.data() + offset, sizeof(KIPHeader));
-        if (kip.magic != Common::MakeMagic('K', 'I', 'P', '1'))
-            return;
-
-        const auto name =
-            Common::StringFromFixedZeroTerminatedBuffer(kip.name.data(), kip.name.size());
-
-        if (name != "FS" && name != "spl") {
-            offset += sizeof(KIPHeader) + kip.sections[0].size_compressed +
-                      kip.sections[1].size_compressed + kip.sections[2].size_compressed;
-            continue;
-        }
-
-        const u64 initial_offset = sizeof(KIPHeader) + offset;
-        const auto text_begin = c.cbegin() + initial_offset;
-        const auto text_end = text_begin + kip.sections[0].size_compressed;
-        const std::vector<u8> text = DecompressBLZ({text_begin, text_end});
-
-        const auto rodata_end = text_end + kip.sections[1].size_compressed;
-        const std::vector<u8> rodata = DecompressBLZ({text_end, rodata_end});
-
-        const auto data_end = rodata_end + kip.sections[2].size_compressed;
-        const std::vector<u8> data = DecompressBLZ({rodata_end, data_end});
-
-        std::vector<u8> out;
-        out.reserve(text.size() + rodata.size() + data.size());
-        out.insert(out.end(), text.begin(), text.end());
-        out.insert(out.end(), rodata.begin(), rodata.end());
-        out.insert(out.end(), data.begin(), data.end());
-
-        offset += sizeof(KIPHeader) + kip.sections[0].size_compressed +
-                  kip.sections[1].size_compressed + kip.sections[2].size_compressed;
-
-        if (name == "FS")
-            package2_fs[static_cast<size_t>(type)] = std::move(out);
-        else if (name == "spl")
-            package2_spl[static_cast<size_t>(type)] = std::move(out);
-    }
-}
-
-const std::vector<u8>& PartitionDataManager::GetPackage2FSDecompressed(Package2Type type) const {
-    return package2_fs.at(static_cast<size_t>(type));
-}
-
-std::array<u8, 16> PartitionDataManager::GetKeyAreaKeyApplicationSource(Package2Type type) const {
-    return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[6]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetKeyAreaKeyOceanSource(Package2Type type) const {
-    return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[7]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetKeyAreaKeySystemSource(Package2Type type) const {
-    return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[8]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetSDKekSource(Package2Type type) const {
-    return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[9]);
-}
-
-std::array<u8, 32> PartitionDataManager::GetSDSaveKeySource(Package2Type type) const {
-    return FindKeyFromHex<0x20>(package2_fs.at(static_cast<size_t>(type)), source_hashes[10]);
-}
-
-std::array<u8, 32> PartitionDataManager::GetSDNCAKeySource(Package2Type type) const {
-    return FindKeyFromHex<0x20>(package2_fs.at(static_cast<size_t>(type)), source_hashes[11]);
-}
-
-std::array<u8, 16> PartitionDataManager::GetHeaderKekSource(Package2Type type) const {
-    return FindKeyFromHex(package2_fs.at(static_cast<size_t>(type)), source_hashes[12]);
-}
-
-std::array<u8, 32> PartitionDataManager::GetHeaderKeySource(Package2Type type) const {
-    return FindKeyFromHex<0x20>(package2_fs.at(static_cast<size_t>(type)), source_hashes[13]);
-}
-
-const std::vector<u8>& PartitionDataManager::GetPackage2SPLDecompressed(Package2Type type) const {
-    return package2_spl.at(static_cast<size_t>(type));
-}
-
-std::array<u8, 16> PartitionDataManager::GetAESKeyGenerationSource(Package2Type type) const {
-    return FindKeyFromHex(package2_spl.at(static_cast<size_t>(type)), source_hashes[4]);
-}
-
-bool PartitionDataManager::HasProdInfo() const {
-    return prodinfo != nullptr;
-}
-
-FileSys::VirtualFile PartitionDataManager::GetProdInfoRaw() const {
-    return prodinfo;
-}
-
-void PartitionDataManager::DecryptProdInfo(std::array<u8, 0x20> bis_key) {
-    if (prodinfo == nullptr)
-        return;
-
-    prodinfo_decrypted = std::make_shared<XTSEncryptionLayer>(prodinfo, bis_key);
-}
-
-std::array<u8, 576> PartitionDataManager::GetETicketExtendedKek() const {
-    std::array<u8, 0x240> out{};
-    if (prodinfo_decrypted != nullptr)
-        prodinfo_decrypted->Read(out.data(), out.size(), 0x3890);
-    return out;
-}
-} // namespace Core::Crypto

src/core/crypto/partition_data_manager.h

@@ -1,109 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
-
-namespace Core::Crypto {
-
-enum class Package2Type {
-    NormalMain,
-    NormalSub,
-    SafeModeMain,
-    SafeModeSub,
-    RepairMain,
-    RepairSub,
-};
-
-class PartitionDataManager {
-public:
-    static const u8 MAX_KEYBLOB_SOURCE_HASH;
-    static constexpr std::size_t NUM_ENCRYPTED_KEYBLOBS = 32;
-    static constexpr std::size_t ENCRYPTED_KEYBLOB_SIZE = 0xB0;
-
-    using EncryptedKeyBlob = std::array<u8, ENCRYPTED_KEYBLOB_SIZE>;
-    using EncryptedKeyBlobs = std::array<EncryptedKeyBlob, NUM_ENCRYPTED_KEYBLOBS>;
-
-    explicit PartitionDataManager(const FileSys::VirtualDir& sysdata_dir);
-    ~PartitionDataManager();
-
-    // BOOT0
-    bool HasBoot0() const;
-    FileSys::VirtualFile GetBoot0Raw() const;
-    EncryptedKeyBlob GetEncryptedKeyblob(std::size_t index) const;
-    EncryptedKeyBlobs GetEncryptedKeyblobs() const;
-    std::vector<u8> GetSecureMonitor() const;
-    std::array<u8, 0x10> GetPackage2KeySource() const;
-    std::array<u8, 0x10> GetAESKekGenerationSource() const;
-    std::array<u8, 0x10> GetTitlekekSource() const;
-    std::array<std::array<u8, 0x10>, 0x20> GetTZMasterKeys(std::array<u8, 0x10> master_key) const;
-    std::array<u8, 0x10> GetRSAKekSeed3() const;
-    std::array<u8, 0x10> GetRSAKekMask0() const;
-    std::vector<u8> GetPackage1Decrypted() const;
-    std::array<u8, 0x10> GetMasterKeySource() const;
-    std::array<u8, 0x10> GetKeyblobMACKeySource() const;
-    std::array<u8, 0x10> GetKeyblobKeySource(std::size_t revision) const;
-
-    // Fuses
-    bool HasFuses() const;
-    FileSys::VirtualFile GetFusesRaw() const;
-    std::array<u8, 0x10> GetSecureBootKey() const;
-
-    // K-Fuses
-    bool HasKFuses() const;
-    FileSys::VirtualFile GetKFusesRaw() const;
-
-    // Package2
-    bool HasPackage2(Package2Type type = Package2Type::NormalMain) const;
-    FileSys::VirtualFile GetPackage2Raw(Package2Type type = Package2Type::NormalMain) const;
-    void DecryptPackage2(const std::array<std::array<u8, 16>, 0x20>& package2_keys,
-                         Package2Type type);
-    const std::vector<u8>& GetPackage2FSDecompressed(
-        Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x10> GetKeyAreaKeyApplicationSource(
-        Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x10> GetKeyAreaKeyOceanSource(
-        Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x10> GetKeyAreaKeySystemSource(
-        Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x10> GetSDKekSource(Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x20> GetSDSaveKeySource(Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x20> GetSDNCAKeySource(Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x10> GetHeaderKekSource(Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x20> GetHeaderKeySource(Package2Type type = Package2Type::NormalMain) const;
-    const std::vector<u8>& GetPackage2SPLDecompressed(
-        Package2Type type = Package2Type::NormalMain) const;
-    std::array<u8, 0x10> GetAESKeyGenerationSource(
-        Package2Type type = Package2Type::NormalMain) const;
-
-    // PRODINFO
-    bool HasProdInfo() const;
-    FileSys::VirtualFile GetProdInfoRaw() const;
-    void DecryptProdInfo(std::array<u8, 0x20> bis_key);
-    std::array<u8, 0x240> GetETicketExtendedKek() const;
-
-private:
-    FileSys::VirtualFile boot0;
-    FileSys::VirtualFile fuses;
-    FileSys::VirtualFile kfuses;
-    std::array<FileSys::VirtualFile, 6> package2;
-    FileSys::VirtualFile prodinfo;
-    FileSys::VirtualFile secure_monitor;
-    FileSys::VirtualFile package1_decrypted;
-
-    // Processed
-    std::array<FileSys::VirtualFile, 6> package2_decrypted;
-    FileSys::VirtualFile prodinfo_decrypted;
-    std::vector<u8> secure_monitor_bytes;
-    std::vector<u8> package1_decrypted_bytes;
-    std::array<std::vector<u8>, 6> package2_fs;
-    std::array<std::vector<u8>, 6> package2_spl;
-};
-
-std::array<u8, 0x10> FindKeyFromHex16(const std::vector<u8>& binary, std::array<u8, 0x20> hash);
-
-} // namespace Core::Crypto

src/core/file_sys/bis_factory.cpp

@@ -10,19 +10,19 @@ namespace FileSys {
 
 BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_)
     : nand_root(std::move(nand_root_)), load_root(std::move(load_root_)),
-      sysnand_cache(std::make_unique<RegisteredCache>(
+      sysnand_cache(std::make_shared<RegisteredCache>(
           GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
-      usrnand_cache(std::make_unique<RegisteredCache>(
+      usrnand_cache(std::make_shared<RegisteredCache>(
           GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))) {}
 
 BISFactory::~BISFactory() = default;
 
-RegisteredCache* BISFactory::GetSystemNANDContents() const {
-    return sysnand_cache.get();
+std::shared_ptr<RegisteredCache> BISFactory::GetSystemNANDContents() const {
+    return sysnand_cache;
 }
 
-RegisteredCache* BISFactory::GetUserNANDContents() const {
-    return usrnand_cache.get();
+std::shared_ptr<RegisteredCache> BISFactory::GetUserNANDContents() const {
+    return usrnand_cache;
 }
 
 VirtualDir BISFactory::GetModificationLoadRoot(u64 title_id) const {

src/core/file_sys/bis_factory.h

@@ -20,8 +20,8 @@ public:
     explicit BISFactory(VirtualDir nand_root, VirtualDir load_root);
     ~BISFactory();
 
-    RegisteredCache* GetSystemNANDContents() const;
-    RegisteredCache* GetUserNANDContents() const;
+    std::shared_ptr<RegisteredCache> GetSystemNANDContents() const;
+    std::shared_ptr<RegisteredCache> GetUserNANDContents() const;
 
     VirtualDir GetModificationLoadRoot(u64 title_id) const;
 
@@ -29,8 +29,8 @@ private:
     VirtualDir nand_root;
     VirtualDir load_root;
 
-    std::unique_ptr<RegisteredCache> sysnand_cache;
-    std::unique_ptr<RegisteredCache> usrnand_cache;
+    std::shared_ptr<RegisteredCache> sysnand_cache;
+    std::shared_ptr<RegisteredCache> usrnand_cache;
 };
 
 } // namespace FileSys

src/core/file_sys/card_image.cpp

@@ -122,16 +122,14 @@ u64 XCI::GetProgramTitleID() const {
     return secure_partition->GetProgramTitleID();
 }
 
-bool XCI::HasProgramNCA() const {
-    return program != nullptr;
+std::shared_ptr<NCA> XCI::GetProgramNCA() const {
+    return program;
 }
 
 VirtualFile XCI::GetProgramNCAFile() const {
-    if (!HasProgramNCA()) {
+    if (GetProgramNCA() == nullptr)
         return nullptr;
-    }
-
-    return program->GetBaseFile();
+    return GetProgramNCA()->GetBaseFile();
 }
 
 const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {

src/core/file_sys/card_image.h

@@ -80,7 +80,7 @@ public:
 
     u64 GetProgramTitleID() const;
 
-    bool HasProgramNCA() const;
+    std::shared_ptr<NCA> GetProgramNCA() const;
     VirtualFile GetProgramNCAFile() const;
     const std::vector<std::shared_ptr<NCA>>& GetNCAs() const;
     std::shared_ptr<NCA> GetNCAByType(NCAContentType type) const;

src/core/file_sys/content_archive.cpp

@@ -97,288 +97,11 @@ union NCASectionHeader {
 };
 static_assert(sizeof(NCASectionHeader) == 0x200, "NCASectionHeader has incorrect size.");
 
-static bool IsValidNCA(const NCAHeader& header) {
+bool IsValidNCA(const NCAHeader& header) {
     // TODO(DarkLordZach): Add NCA2/NCA0 support.
     return header.magic == Common::MakeMagic('N', 'C', 'A', '3');
 }
 
-NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
-    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)) {
-    if (file == nullptr) {
-        status = Loader::ResultStatus::ErrorNullFile;
-        return;
-    }
-
-    if (sizeof(NCAHeader) != file->ReadObject(&header)) {
-        LOG_ERROR(Loader, "File reader errored out during header read.");
-        status = Loader::ResultStatus::ErrorBadNCAHeader;
-        return;
-    }
-
-    if (!HandlePotentialHeaderDecryption()) {
-        return;
-    }
-
-    has_rights_id = std::any_of(header.rights_id.begin(), header.rights_id.end(),
-                                [](char c) { return c != '\0'; });
-
-    const std::vector<NCASectionHeader> sections = ReadSectionHeaders();
-    is_update = std::any_of(sections.begin(), sections.end(), [](const NCASectionHeader& header) {
-        return header.raw.header.crypto_type == NCASectionCryptoType::BKTR;
-    });
-
-    if (!ReadSections(sections, bktr_base_ivfc_offset)) {
-        return;
-    }
-
-    status = Loader::ResultStatus::Success;
-}
-
-NCA::~NCA() = default;
-
-bool NCA::CheckSupportedNCA(const NCAHeader& nca_header) {
-    if (nca_header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
-        status = Loader::ResultStatus::ErrorNCA2;
-        return false;
-    }
-
-    if (nca_header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
-        status = Loader::ResultStatus::ErrorNCA0;
-        return false;
-    }
-
-    return true;
-}
-
-bool NCA::HandlePotentialHeaderDecryption() {
-    if (IsValidNCA(header)) {
-        return true;
-    }
-
-    if (!CheckSupportedNCA(header)) {
-        return false;
-    }
-
-    NCAHeader dec_header{};
-    Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
-        keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
-    cipher.XTSTranscode(&header, sizeof(NCAHeader), &dec_header, 0, 0x200,
-                        Core::Crypto::Op::Decrypt);
-    if (IsValidNCA(dec_header)) {
-        header = dec_header;
-        encrypted = true;
-    } else {
-        if (!CheckSupportedNCA(dec_header)) {
-            return false;
-        }
-
-        if (keys.HasKey(Core::Crypto::S256KeyType::Header)) {
-            status = Loader::ResultStatus::ErrorIncorrectHeaderKey;
-        } else {
-            status = Loader::ResultStatus::ErrorMissingHeaderKey;
-        }
-        return false;
-    }
-
-    return true;
-}
-
-std::vector<NCASectionHeader> NCA::ReadSectionHeaders() const {
-    const std::ptrdiff_t number_sections =
-        std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
-                      [](NCASectionTableEntry entry) { return entry.media_offset > 0; });
-
-    std::vector<NCASectionHeader> sections(number_sections);
-    const auto length_sections = SECTION_HEADER_SIZE * number_sections;
-
-    if (encrypted) {
-        auto raw = file->ReadBytes(length_sections, SECTION_HEADER_OFFSET);
-        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
-            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
-        cipher.XTSTranscode(raw.data(), length_sections, sections.data(), 2, SECTION_HEADER_SIZE,
-                            Core::Crypto::Op::Decrypt);
-    } else {
-        file->ReadBytes(sections.data(), length_sections, SECTION_HEADER_OFFSET);
-    }
-
-    return sections;
-}
-
-bool NCA::ReadSections(const std::vector<NCASectionHeader>& sections, u64 bktr_base_ivfc_offset) {
-    for (std::size_t i = 0; i < sections.size(); ++i) {
-        const auto& section = sections[i];
-
-        if (section.raw.header.filesystem_type == NCASectionFilesystemType::ROMFS) {
-            if (!ReadRomFSSection(section, header.section_tables[i], bktr_base_ivfc_offset)) {
-                return false;
-            }
-        } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
-            if (!ReadPFS0Section(section, header.section_tables[i])) {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTableEntry& entry,
-                           u64 bktr_base_ivfc_offset) {
-    const std::size_t base_offset = entry.media_offset * MEDIA_OFFSET_MULTIPLIER;
-    ivfc_offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
-    const std::size_t romfs_offset = base_offset + ivfc_offset;
-    const std::size_t romfs_size = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
-    auto raw = std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset);
-    auto dec = Decrypt(section, raw, romfs_offset);
-
-    if (dec == nullptr) {
-        if (status != Loader::ResultStatus::Success)
-            return false;
-        if (has_rights_id)
-            status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-        else
-            status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
-        return false;
-    }
-
-    if (section.raw.header.crypto_type == NCASectionCryptoType::BKTR) {
-        if (section.bktr.relocation.magic != Common::MakeMagic('B', 'K', 'T', 'R') ||
-            section.bktr.subsection.magic != Common::MakeMagic('B', 'K', 'T', 'R')) {
-            status = Loader::ResultStatus::ErrorBadBKTRHeader;
-            return false;
-        }
-
-        if (section.bktr.relocation.offset + section.bktr.relocation.size !=
-            section.bktr.subsection.offset) {
-            status = Loader::ResultStatus::ErrorBKTRSubsectionNotAfterRelocation;
-            return false;
-        }
-
-        const u64 size = MEDIA_OFFSET_MULTIPLIER * (entry.media_end_offset - entry.media_offset);
-        if (section.bktr.subsection.offset + section.bktr.subsection.size != size) {
-            status = Loader::ResultStatus::ErrorBKTRSubsectionNotAtEnd;
-            return false;
-        }
-
-        const u64 offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
-        RelocationBlock relocation_block{};
-        if (dec->ReadObject(&relocation_block, section.bktr.relocation.offset - offset) !=
-            sizeof(RelocationBlock)) {
-            status = Loader::ResultStatus::ErrorBadRelocationBlock;
-            return false;
-        }
-        SubsectionBlock subsection_block{};
-        if (dec->ReadObject(&subsection_block, section.bktr.subsection.offset - offset) !=
-            sizeof(RelocationBlock)) {
-            status = Loader::ResultStatus::ErrorBadSubsectionBlock;
-            return false;
-        }
-
-        std::vector<RelocationBucketRaw> relocation_buckets_raw(
-            (section.bktr.relocation.size - sizeof(RelocationBlock)) / sizeof(RelocationBucketRaw));
-        if (dec->ReadBytes(relocation_buckets_raw.data(),
-                           section.bktr.relocation.size - sizeof(RelocationBlock),
-                           section.bktr.relocation.offset + sizeof(RelocationBlock) - offset) !=
-            section.bktr.relocation.size - sizeof(RelocationBlock)) {
-            status = Loader::ResultStatus::ErrorBadRelocationBuckets;
-            return false;
-        }
-
-        std::vector<SubsectionBucketRaw> subsection_buckets_raw(
-            (section.bktr.subsection.size - sizeof(SubsectionBlock)) / sizeof(SubsectionBucketRaw));
-        if (dec->ReadBytes(subsection_buckets_raw.data(),
-                           section.bktr.subsection.size - sizeof(SubsectionBlock),
-                           section.bktr.subsection.offset + sizeof(SubsectionBlock) - offset) !=
-            section.bktr.subsection.size - sizeof(SubsectionBlock)) {
-            status = Loader::ResultStatus::ErrorBadSubsectionBuckets;
-            return false;
-        }
-
-        std::vector<RelocationBucket> relocation_buckets(relocation_buckets_raw.size());
-        std::transform(relocation_buckets_raw.begin(), relocation_buckets_raw.end(),
-                       relocation_buckets.begin(), &ConvertRelocationBucketRaw);
-        std::vector<SubsectionBucket> subsection_buckets(subsection_buckets_raw.size());
-        std::transform(subsection_buckets_raw.begin(), subsection_buckets_raw.end(),
-                       subsection_buckets.begin(), &ConvertSubsectionBucketRaw);
-
-        u32 ctr_low;
-        std::memcpy(&ctr_low, section.raw.section_ctr.data(), sizeof(ctr_low));
-        subsection_buckets.back().entries.push_back({section.bktr.relocation.offset, {0}, ctr_low});
-        subsection_buckets.back().entries.push_back({size, {0}, 0});
-
-        boost::optional<Core::Crypto::Key128> key = boost::none;
-        if (encrypted) {
-            if (has_rights_id) {
-                status = Loader::ResultStatus::Success;
-                key = GetTitlekey();
-                if (key == boost::none) {
-                    status = Loader::ResultStatus::ErrorMissingTitlekey;
-                    return false;
-                }
-            } else {
-                key = GetKeyAreaKey(NCASectionCryptoType::BKTR);
-                if (key == boost::none) {
-                    status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
-                    return false;
-                }
-            }
-        }
-
-        if (bktr_base_romfs == nullptr) {
-            status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
-            return false;
-        }
-
-        auto bktr = std::make_shared<BKTR>(
-            bktr_base_romfs, std::make_shared<OffsetVfsFile>(file, romfs_size, base_offset),
-            relocation_block, relocation_buckets, subsection_block, subsection_buckets, encrypted,
-            encrypted ? key.get() : Core::Crypto::Key128{}, base_offset, bktr_base_ivfc_offset,
-            section.raw.section_ctr);
-
-        // BKTR applies to entire IVFC, so make an offset version to level 6
-        files.push_back(std::make_shared<OffsetVfsFile>(
-            bktr, romfs_size, section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset));
-    } else {
-        files.push_back(std::move(dec));
-    }
-
-    romfs = files.back();
-    return true;
-}
-
-bool NCA::ReadPFS0Section(const NCASectionHeader& section, const NCASectionTableEntry& entry) {
-    const u64 offset = (static_cast<u64>(entry.media_offset) * MEDIA_OFFSET_MULTIPLIER) +
-                       section.pfs0.pfs0_header_offset;
-    const u64 size = MEDIA_OFFSET_MULTIPLIER * (entry.media_end_offset - entry.media_offset);
-
-    auto dec = Decrypt(section, std::make_shared<OffsetVfsFile>(file, size, offset), offset);
-    if (dec != nullptr) {
-        auto npfs = std::make_shared<PartitionFilesystem>(std::move(dec));
-
-        if (npfs->GetStatus() == Loader::ResultStatus::Success) {
-            dirs.push_back(std::move(npfs));
-            if (IsDirectoryExeFS(dirs.back()))
-                exefs = dirs.back();
-        } else {
-            if (has_rights_id)
-                status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-            else
-                status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
-            return false;
-        }
-    } else {
-        if (status != Loader::ResultStatus::Success)
-            return false;
-        if (has_rights_id)
-            status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-        else
-            status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
-        return false;
-    }
-
-    return true;
-}
-
 u8 NCA::GetCryptoRevision() const {
     u8 master_key_id = header.crypto_type;
     if (header.crypto_type_2 > master_key_id)
@@ -410,7 +133,7 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
                      static_cast<u8>(type));
     u128 out_128{};
     memcpy(out_128.data(), out.data(), 16);
-    LOG_TRACE(Crypto, "called with crypto_rev={:02X}, kak_index={:02X}, key={:016X}{:016X}",
+    LOG_DEBUG(Crypto, "called with crypto_rev={:02X}, kak_index={:02X}, key={:016X}{:016X}",
               master_key_id, header.key_index, out_128[1], out_128[0]);
 
     return out;
@@ -444,7 +167,7 @@ boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
     return titlekey;
 }
 
-VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 starting_offset) {
+VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting_offset) {
     if (!encrypted)
         return in;
 
@@ -492,6 +215,256 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
     }
 }
 
+NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
+    : file(std::move(file_)),
+      bktr_base_romfs(bktr_base_romfs_ ? std::move(bktr_base_romfs_) : nullptr) {
+    status = Loader::ResultStatus::Success;
+
+    if (file == nullptr) {
+        status = Loader::ResultStatus::ErrorNullFile;
+        return;
+    }
+
+    if (sizeof(NCAHeader) != file->ReadObject(&header)) {
+        LOG_ERROR(Loader, "File reader errored out during header read.");
+        status = Loader::ResultStatus::ErrorBadNCAHeader;
+        return;
+    }
+
+    encrypted = false;
+
+    if (!IsValidNCA(header)) {
+        if (header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
+            status = Loader::ResultStatus::ErrorNCA2;
+            return;
+        }
+        if (header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
+            status = Loader::ResultStatus::ErrorNCA0;
+            return;
+        }
+
+        NCAHeader dec_header{};
+        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
+            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
+        cipher.XTSTranscode(&header, sizeof(NCAHeader), &dec_header, 0, 0x200,
+                            Core::Crypto::Op::Decrypt);
+        if (IsValidNCA(dec_header)) {
+            header = dec_header;
+            encrypted = true;
+        } else {
+            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '2')) {
+                status = Loader::ResultStatus::ErrorNCA2;
+                return;
+            }
+            if (dec_header.magic == Common::MakeMagic('N', 'C', 'A', '0')) {
+                status = Loader::ResultStatus::ErrorNCA0;
+                return;
+            }
+
+            if (!keys.HasKey(Core::Crypto::S256KeyType::Header))
+                status = Loader::ResultStatus::ErrorMissingHeaderKey;
+            else
+                status = Loader::ResultStatus::ErrorIncorrectHeaderKey;
+            return;
+        }
+    }
+
+    has_rights_id = std::find_if_not(header.rights_id.begin(), header.rights_id.end(),
+                                     [](char c) { return c == '\0'; }) != header.rights_id.end();
+
+    const std::ptrdiff_t number_sections =
+        std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
+                      [](NCASectionTableEntry entry) { return entry.media_offset > 0; });
+
+    std::vector<NCASectionHeader> sections(number_sections);
+    const auto length_sections = SECTION_HEADER_SIZE * number_sections;
+
+    if (encrypted) {
+        auto raw = file->ReadBytes(length_sections, SECTION_HEADER_OFFSET);
+        Core::Crypto::AESCipher<Core::Crypto::Key256> cipher(
+            keys.GetKey(Core::Crypto::S256KeyType::Header), Core::Crypto::Mode::XTS);
+        cipher.XTSTranscode(raw.data(), length_sections, sections.data(), 2, SECTION_HEADER_SIZE,
+                            Core::Crypto::Op::Decrypt);
+    } else {
+        file->ReadBytes(sections.data(), length_sections, SECTION_HEADER_OFFSET);
+    }
+
+    is_update = std::find_if(sections.begin(), sections.end(), [](const NCASectionHeader& header) {
+                    return header.raw.header.crypto_type == NCASectionCryptoType::BKTR;
+                }) != sections.end();
+    ivfc_offset = 0;
+
+    for (std::ptrdiff_t i = 0; i < number_sections; ++i) {
+        auto section = sections[i];
+
+        if (section.raw.header.filesystem_type == NCASectionFilesystemType::ROMFS) {
+            const std::size_t base_offset =
+                header.section_tables[i].media_offset * MEDIA_OFFSET_MULTIPLIER;
+            ivfc_offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
+            const std::size_t romfs_offset = base_offset + ivfc_offset;
+            const std::size_t romfs_size = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
+            auto raw = std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset);
+            auto dec = Decrypt(section, raw, romfs_offset);
+
+            if (dec == nullptr) {
+                if (status != Loader::ResultStatus::Success)
+                    return;
+                if (has_rights_id)
+                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
+                else
+                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+                return;
+            }
+
+            if (section.raw.header.crypto_type == NCASectionCryptoType::BKTR) {
+                if (section.bktr.relocation.magic != Common::MakeMagic('B', 'K', 'T', 'R') ||
+                    section.bktr.subsection.magic != Common::MakeMagic('B', 'K', 'T', 'R')) {
+                    status = Loader::ResultStatus::ErrorBadBKTRHeader;
+                    return;
+                }
+
+                if (section.bktr.relocation.offset + section.bktr.relocation.size !=
+                    section.bktr.subsection.offset) {
+                    status = Loader::ResultStatus::ErrorBKTRSubsectionNotAfterRelocation;
+                    return;
+                }
+
+                const u64 size =
+                    MEDIA_OFFSET_MULTIPLIER * (header.section_tables[i].media_end_offset -
+                                               header.section_tables[i].media_offset);
+                if (section.bktr.subsection.offset + section.bktr.subsection.size != size) {
+                    status = Loader::ResultStatus::ErrorBKTRSubsectionNotAtEnd;
+                    return;
+                }
+
+                const u64 offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
+                RelocationBlock relocation_block{};
+                if (dec->ReadObject(&relocation_block, section.bktr.relocation.offset - offset) !=
+                    sizeof(RelocationBlock)) {
+                    status = Loader::ResultStatus::ErrorBadRelocationBlock;
+                    return;
+                }
+                SubsectionBlock subsection_block{};
+                if (dec->ReadObject(&subsection_block, section.bktr.subsection.offset - offset) !=
+                    sizeof(RelocationBlock)) {
+                    status = Loader::ResultStatus::ErrorBadSubsectionBlock;
+                    return;
+                }
+
+                std::vector<RelocationBucketRaw> relocation_buckets_raw(
+                    (section.bktr.relocation.size - sizeof(RelocationBlock)) /
+                    sizeof(RelocationBucketRaw));
+                if (dec->ReadBytes(relocation_buckets_raw.data(),
+                                   section.bktr.relocation.size - sizeof(RelocationBlock),
+                                   section.bktr.relocation.offset + sizeof(RelocationBlock) -
+                                       offset) !=
+                    section.bktr.relocation.size - sizeof(RelocationBlock)) {
+                    status = Loader::ResultStatus::ErrorBadRelocationBuckets;
+                    return;
+                }
+
+                std::vector<SubsectionBucketRaw> subsection_buckets_raw(
+                    (section.bktr.subsection.size - sizeof(SubsectionBlock)) /
+                    sizeof(SubsectionBucketRaw));
+                if (dec->ReadBytes(subsection_buckets_raw.data(),
+                                   section.bktr.subsection.size - sizeof(SubsectionBlock),
+                                   section.bktr.subsection.offset + sizeof(SubsectionBlock) -
+                                       offset) !=
+                    section.bktr.subsection.size - sizeof(SubsectionBlock)) {
+                    status = Loader::ResultStatus::ErrorBadSubsectionBuckets;
+                    return;
+                }
+
+                std::vector<RelocationBucket> relocation_buckets(relocation_buckets_raw.size());
+                std::transform(relocation_buckets_raw.begin(), relocation_buckets_raw.end(),
+                               relocation_buckets.begin(), &ConvertRelocationBucketRaw);
+                std::vector<SubsectionBucket> subsection_buckets(subsection_buckets_raw.size());
+                std::transform(subsection_buckets_raw.begin(), subsection_buckets_raw.end(),
+                               subsection_buckets.begin(), &ConvertSubsectionBucketRaw);
+
+                u32 ctr_low;
+                std::memcpy(&ctr_low, section.raw.section_ctr.data(), sizeof(ctr_low));
+                subsection_buckets.back().entries.push_back(
+                    {section.bktr.relocation.offset, {0}, ctr_low});
+                subsection_buckets.back().entries.push_back({size, {0}, 0});
+
+                boost::optional<Core::Crypto::Key128> key = boost::none;
+                if (encrypted) {
+                    if (has_rights_id) {
+                        status = Loader::ResultStatus::Success;
+                        key = GetTitlekey();
+                        if (key == boost::none) {
+                            status = Loader::ResultStatus::ErrorMissingTitlekey;
+                            return;
+                        }
+                    } else {
+                        key = GetKeyAreaKey(NCASectionCryptoType::BKTR);
+                        if (key == boost::none) {
+                            status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
+                            return;
+                        }
+                    }
+                }
+
+                if (bktr_base_romfs == nullptr) {
+                    status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
+                    return;
+                }
+
+                auto bktr = std::make_shared<BKTR>(
+                    bktr_base_romfs, std::make_shared<OffsetVfsFile>(file, romfs_size, base_offset),
+                    relocation_block, relocation_buckets, subsection_block, subsection_buckets,
+                    encrypted, encrypted ? key.get() : Core::Crypto::Key128{}, base_offset,
+                    bktr_base_ivfc_offset, section.raw.section_ctr);
+
+                // BKTR applies to entire IVFC, so make an offset version to level 6
+
+                files.push_back(std::make_shared<OffsetVfsFile>(
+                    bktr, romfs_size, section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset));
+                romfs = files.back();
+            } else {
+                files.push_back(std::move(dec));
+                romfs = files.back();
+            }
+        } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
+            u64 offset = (static_cast<u64>(header.section_tables[i].media_offset) *
+                          MEDIA_OFFSET_MULTIPLIER) +
+                         section.pfs0.pfs0_header_offset;
+            u64 size = MEDIA_OFFSET_MULTIPLIER * (header.section_tables[i].media_end_offset -
+                                                  header.section_tables[i].media_offset);
+            auto dec =
+                Decrypt(section, std::make_shared<OffsetVfsFile>(file, size, offset), offset);
+            if (dec != nullptr) {
+                auto npfs = std::make_shared<PartitionFilesystem>(std::move(dec));
+
+                if (npfs->GetStatus() == Loader::ResultStatus::Success) {
+                    dirs.push_back(std::move(npfs));
+                    if (IsDirectoryExeFS(dirs.back()))
+                        exefs = dirs.back();
+                } else {
+                    if (has_rights_id)
+                        status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
+                    else
+                        status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+                    return;
+                }
+            } else {
+                if (status != Loader::ResultStatus::Success)
+                    return;
+                if (has_rights_id)
+                    status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
+                else
+                    status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
+                return;
+            }
+        }
+    }
+
+    status = Loader::ResultStatus::Success;
+}
+
+NCA::~NCA() = default;
+
 Loader::ResultStatus NCA::GetStatus() const {
     return status;
 }

src/core/file_sys/content_archive.h

@@ -73,6 +73,8 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
 
+bool IsValidNCA(const NCAHeader& header);
+
 // An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
@@ -104,19 +106,10 @@ protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
-    bool CheckSupportedNCA(const NCAHeader& header);
-    bool HandlePotentialHeaderDecryption();
-
-    std::vector<NCASectionHeader> ReadSectionHeaders() const;
-    bool ReadSections(const std::vector<NCASectionHeader>& sections, u64 bktr_base_ivfc_offset);
-    bool ReadRomFSSection(const NCASectionHeader& section, const NCASectionTableEntry& entry,
-                          u64 bktr_base_ivfc_offset);
-    bool ReadPFS0Section(const NCASectionHeader& section, const NCASectionTableEntry& entry);
-
     u8 GetCryptoRevision() const;
     boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
     boost::optional<Core::Crypto::Key128> GetTitlekey();
-    VirtualFile Decrypt(const NCASectionHeader& header, VirtualFile in, u64 starting_offset);
+    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset);
 
     std::vector<VirtualDir> dirs;
     std::vector<VirtualFile> files;
@@ -125,15 +118,15 @@ private:
     VirtualDir exefs = nullptr;
     VirtualFile file;
     VirtualFile bktr_base_romfs;
-    u64 ivfc_offset = 0;
+    u64 ivfc_offset;
 
     NCAHeader header{};
     bool has_rights_id{};
 
     Loader::ResultStatus status{};
 
-    bool encrypted = false;
-    bool is_update = false;
+    bool encrypted;
+    bool is_update;
 
     Core::Crypto::KeyManager keys;
 };

src/core/file_sys/control_metadata.cpp

@@ -17,13 +17,11 @@ const std::array<const char*, 15> LANGUAGE_NAMES = {
 };
 
 std::string LanguageEntry::GetApplicationName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(),
-                                                       application_name.size());
+    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(), 0x200);
 }
 
 std::string LanguageEntry::GetDeveloperName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(),
-                                                       developer_name.size());
+    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(), 0x100);
 }
 
 NACP::NACP(VirtualFile file) : raw(std::make_unique<RawNACP>()) {
@@ -58,12 +56,7 @@ u64 NACP::GetTitleId() const {
     return raw->title_id;
 }
 
-u64 NACP::GetDLCBaseTitleId() const {
-    return raw->dlc_base_title_id;
-}
-
 std::string NACP::GetVersionString() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(),
-                                                       raw->version_string.size());
+    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(), 0x10);
 }
 } // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -79,7 +79,6 @@ public:
     std::string GetApplicationName(Language language = Language::Default) const;
     std::string GetDeveloperName(Language language = Language::Default) const;
     u64 GetTitleId() const;
-    u64 GetDLCBaseTitleId() const;
     std::string GetVersionString() const;
 
 private:

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -26,7 +26,6 @@
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "core/file_sys/fsmitm_romfsbuild.h"
-#include "core/file_sys/ips_layer.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_vector.h"
 
@@ -124,7 +123,7 @@ static u64 romfs_get_hash_table_count(u64 num_entries) {
     return count;
 }
 
-void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
+void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs,
                                        std::shared_ptr<RomFSBuildDirectoryContext> parent) {
     std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> child_dirs;
 
@@ -145,9 +144,6 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
             child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
             child->path = parent->path + "/" + kv.first;
 
-            if (ext != nullptr && ext->GetFileRelative(child->path + ".stub") != nullptr)
-                continue;
-
             // Sanity check on path_len
             ASSERT(child->path_len < FS_MAX_PATH);
 
@@ -161,24 +157,11 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
             child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
             child->path = parent->path + "/" + kv.first;
 
-            if (ext != nullptr && ext->GetFileRelative(child->path + ".stub") != nullptr)
-                continue;
-
             // Sanity check on path_len
             ASSERT(child->path_len < FS_MAX_PATH);
 
             child->source = root_romfs->GetFileRelative(child->path);
 
-            if (ext != nullptr) {
-                const auto ips = ext->GetFileRelative(child->path + ".ips");
-
-                if (ips != nullptr) {
-                    auto patched = PatchIPS(child->source, ips);
-                    if (patched != nullptr)
-                        child->source = std::move(patched);
-                }
-            }
-
             child->size = child->source->GetSize();
 
             AddFile(parent, child);
@@ -186,7 +169,7 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
     }
 
     for (auto& child : child_dirs) {
-        this->VisitDirectory(root_romfs, ext, child);
+        this->VisitDirectory(root_romfs, child);
     }
 }
 
@@ -225,15 +208,14 @@ bool RomFSBuildContext::AddFile(std::shared_ptr<RomFSBuildDirectoryContext> pare
     return true;
 }
 
-RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
-    : base(std::move(base_)), ext(std::move(ext_)) {
+RomFSBuildContext::RomFSBuildContext(VirtualDir base_) : base(std::move(base_)) {
     root = std::make_shared<RomFSBuildDirectoryContext>();
     root->path = "\0";
     directories.emplace(root->path, root);
     num_dirs = 1;
     dir_table_size = 0x18;
 
-    VisitDirectory(base, ext, root);
+    VisitDirectory(base, root);
 }
 
 RomFSBuildContext::~RomFSBuildContext() = default;

src/core/file_sys/fsmitm_romfsbuild.h

@@ -40,7 +40,7 @@ struct RomFSFileEntry;
 
 class RomFSBuildContext {
 public:
-    explicit RomFSBuildContext(VirtualDir base, VirtualDir ext = nullptr);
+    explicit RomFSBuildContext(VirtualDir base);
     ~RomFSBuildContext();
 
     // This finalizes the context.
@@ -48,7 +48,6 @@ public:
 
 private:
     VirtualDir base;
-    VirtualDir ext;
     std::shared_ptr<RomFSBuildDirectoryContext> root;
     std::map<std::string, std::shared_ptr<RomFSBuildDirectoryContext>, std::less<>> directories;
     std::map<std::string, std::shared_ptr<RomFSBuildFileContext>, std::less<>> files;
@@ -60,8 +59,7 @@ private:
     u64 file_hash_table_size = 0;
     u64 file_partition_size = 0;
 
-    void VisitDirectory(VirtualDir filesys, VirtualDir ext,
-                        std::shared_ptr<RomFSBuildDirectoryContext> parent);
+    void VisitDirectory(VirtualDir filesys, std::shared_ptr<RomFSBuildDirectoryContext> parent);
 
     bool AddDirectory(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx,
                       std::shared_ptr<RomFSBuildDirectoryContext> dir_ctx);

src/core/file_sys/ips_layer.cpp

@@ -2,15 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <cstring>
-#include <map>
-#include <sstream>
-#include <string>
-#include <utility>
-
-#include "common/hex_util.h"
-#include "common/logging/log.h"
+#include "common/assert.h"
 #include "common/swap.h"
 #include "core/file_sys/ips_layer.h"
 #include "core/file_sys/vfs_vector.h"
@@ -23,48 +15,16 @@ enum class IPSFileType {
     Error,
 };
 
-constexpr std::array<std::pair<const char*, const char*>, 11> ESCAPE_CHARACTER_MAP{{
-    {"\\a", "\a"},
-    {"\\b", "\b"},
-    {"\\f", "\f"},
-    {"\\n", "\n"},
-    {"\\r", "\r"},
-    {"\\t", "\t"},
-    {"\\v", "\v"},
-    {"\\\\", "\\"},
-    {"\\\'", "\'"},
-    {"\\\"", "\""},
-    {"\\\?", "\?"},
-}};
-
 static IPSFileType IdentifyMagic(const std::vector<u8>& magic) {
-    if (magic.size() != 5) {
+    if (magic.size() != 5)
         return IPSFileType::Error;
-    }
-
-    constexpr std::array<u8, 5> patch_magic{{'P', 'A', 'T', 'C', 'H'}};
-    if (std::equal(magic.begin(), magic.end(), patch_magic.begin())) {
+    if (magic == std::vector<u8>{'P', 'A', 'T', 'C', 'H'})
         return IPSFileType::IPS;
-    }
-
-    constexpr std::array<u8, 5> ips32_magic{{'I', 'P', 'S', '3', '2'}};
-    if (std::equal(magic.begin(), magic.end(), ips32_magic.begin())) {
+    if (magic == std::vector<u8>{'I', 'P', 'S', '3', '2'})
         return IPSFileType::IPS32;
-    }
-
     return IPSFileType::Error;
 }
 
-static bool IsEOF(IPSFileType type, const std::vector<u8>& data) {
-    constexpr std::array<u8, 3> eof{{'E', 'O', 'F'}};
-    if (type == IPSFileType::IPS && std::equal(data.begin(), data.end(), eof.begin())) {
-        return true;
-    }
-
-    constexpr std::array<u8, 4> eeof{{'E', 'E', 'O', 'F'}};
-    return type == IPSFileType::IPS32 && std::equal(data.begin(), data.end(), eeof.begin());
-}
-
 VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
     if (in == nullptr || ips == nullptr)
         return nullptr;
@@ -79,7 +39,8 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
     u64 offset = 5; // After header
     while (ips->Read(temp.data(), temp.size(), offset) == temp.size()) {
         offset += temp.size();
-        if (IsEOF(type, temp)) {
+        if (type == IPSFileType::IPS32 && temp == std::vector<u8>{'E', 'E', 'O', 'F'} ||
+            type == IPSFileType::IPS && temp == std::vector<u8>{'E', 'O', 'F'}) {
             break;
         }
 
@@ -107,232 +68,21 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
                 return nullptr;
 
             if (real_offset + rle_size > in_data.size())
-                rle_size = static_cast<u16>(in_data.size() - real_offset);
+                rle_size = in_data.size() - real_offset;
             std::memset(in_data.data() + real_offset, data.get(), rle_size);
         } else { // Standard Patch
             auto read = data_size;
             if (real_offset + read > in_data.size())
-                read = static_cast<u16>(in_data.size() - real_offset);
+                read = in_data.size() - real_offset;
             if (ips->Read(in_data.data() + real_offset, read, offset) != data_size)
                 return nullptr;
             offset += data_size;
         }
     }
 
-    if (!IsEOF(type, temp)) {
+    if (temp != std::vector<u8>{'E', 'E', 'O', 'F'} && temp != std::vector<u8>{'E', 'O', 'F'})
         return nullptr;
-    }
-
-    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
-                                           in->GetContainingDirectory());
-}
-
-struct IPSwitchCompiler::IPSwitchPatch {
-    std::string name;
-    bool enabled;
-    std::map<u32, std::vector<u8>> records;
-};
-
-IPSwitchCompiler::IPSwitchCompiler(VirtualFile patch_text_) : patch_text(std::move(patch_text_)) {
-    Parse();
-}
-
-IPSwitchCompiler::~IPSwitchCompiler() = default;
-
-std::array<u8, 32> IPSwitchCompiler::GetBuildID() const {
-    return nso_build_id;
-}
-
-bool IPSwitchCompiler::IsValid() const {
-    return valid;
-}
-
-static bool StartsWith(std::string_view base, std::string_view check) {
-    return base.size() >= check.size() && base.substr(0, check.size()) == check;
-}
-
-static std::string EscapeStringSequences(std::string in) {
-    for (const auto& seq : ESCAPE_CHARACTER_MAP) {
-        for (auto index = in.find(seq.first); index != std::string::npos;
-             index = in.find(seq.first, index)) {
-            in.replace(index, std::strlen(seq.first), seq.second);
-            index += std::strlen(seq.second);
-        }
-    }
-
-    return in;
-}
-
-void IPSwitchCompiler::ParseFlag(const std::string& line) {
-    if (StartsWith(line, "@flag offset_shift ")) {
-        // Offset Shift Flag
-        offset_shift = std::stoll(line.substr(19), nullptr, 0);
-    } else if (StartsWith(line, "@little-endian")) {
-        // Set values to read as little endian
-        is_little_endian = true;
-    } else if (StartsWith(line, "@big-endian")) {
-        // Set values to read as big endian
-        is_little_endian = false;
-    } else if (StartsWith(line, "@flag print_values")) {
-        // Force printing of applied values
-        print_values = true;
-    }
-}
-
-void IPSwitchCompiler::Parse() {
-    const auto bytes = patch_text->ReadAllBytes();
-    std::stringstream s;
-    s.write(reinterpret_cast<const char*>(bytes.data()), bytes.size());
-
-    std::vector<std::string> lines;
-    std::string stream_line;
-    while (std::getline(s, stream_line)) {
-        // Remove a trailing \r
-        if (!stream_line.empty() && stream_line.back() == '\r')
-            stream_line.pop_back();
-        lines.push_back(std::move(stream_line));
-    }
-
-    for (std::size_t i = 0; i < lines.size(); ++i) {
-        auto line = lines[i];
-
-        // Remove midline comments
-        std::size_t comment_index = std::string::npos;
-        bool within_string = false;
-        for (std::size_t k = 0; k < line.size(); ++k) {
-            if (line[k] == '\"' && (k > 0 && line[k - 1] != '\\')) {
-                within_string = !within_string;
-            } else if (line[k] == '\\' && (k < line.size() - 1 && line[k + 1] == '\\')) {
-                comment_index = k;
-                break;
-            }
-        }
-
-        if (!StartsWith(line, "//") && comment_index != std::string::npos) {
-            last_comment = line.substr(comment_index + 2);
-            line = line.substr(0, comment_index);
-        }
-
-        if (StartsWith(line, "@stop")) {
-            // Force stop
-            break;
-        } else if (StartsWith(line, "@nsobid-")) {
-            // NSO Build ID Specifier
-            auto raw_build_id = line.substr(8);
-            if (raw_build_id.size() != 0x40)
-                raw_build_id.resize(0x40, '0');
-            nso_build_id = Common::HexStringToArray<0x20>(raw_build_id);
-        } else if (StartsWith(line, "#")) {
-            // Mandatory Comment
-            LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Forced output comment: {}",
-                     patch_text->GetName(), line.substr(1));
-        } else if (StartsWith(line, "//")) {
-            // Normal Comment
-            last_comment = line.substr(2);
-            if (last_comment.find_first_not_of(' ') == std::string::npos)
-                continue;
-            if (last_comment.find_first_not_of(' ') != 0)
-                last_comment = last_comment.substr(last_comment.find_first_not_of(' '));
-        } else if (StartsWith(line, "@enabled") || StartsWith(line, "@disabled")) {
-            // Start of patch
-            const auto enabled = StartsWith(line, "@enabled");
-            if (i == 0)
-                return;
-            LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Parsing patch '{}' ({})",
-                     patch_text->GetName(), last_comment, line.substr(1));
-
-            IPSwitchPatch patch{last_comment, enabled, {}};
-
-            // Read rest of patch
-            while (true) {
-                if (i + 1 >= lines.size())
-                    break;
-                const auto patch_line = lines[++i];
-
-                // Start of new patch
-                if (StartsWith(patch_line, "@enabled") || StartsWith(patch_line, "@disabled")) {
-                    --i;
-                    break;
-                }
-
-                // Check for a flag
-                if (StartsWith(patch_line, "@")) {
-                    ParseFlag(patch_line);
-                    continue;
-                }
-
-                // 11 - 8 hex digit offset + space + minimum two digit overwrite val
-                if (patch_line.length() < 11)
-                    break;
-                auto offset = std::stoul(patch_line.substr(0, 8), nullptr, 16);
-                offset += static_cast<unsigned long>(offset_shift);
-
-                std::vector<u8> replace;
-                // 9 - first char of replacement val
-                if (patch_line[9] == '\"') {
-                    // string replacement
-                    auto end_index = patch_line.find('\"', 10);
-                    if (end_index == std::string::npos || end_index < 10)
-                        return;
-                    while (patch_line[end_index - 1] == '\\') {
-                        end_index = patch_line.find('\"', end_index + 1);
-                        if (end_index == std::string::npos || end_index < 10)
-                            return;
-                    }
-
-                    auto value = patch_line.substr(10, end_index - 10);
-                    value = EscapeStringSequences(value);
-                    replace.reserve(value.size());
-                    std::copy(value.begin(), value.end(), std::back_inserter(replace));
-                } else {
-                    // hex replacement
-                    const auto value = patch_line.substr(9);
-                    replace.reserve(value.size() / 2);
-                    replace = Common::HexStringToVector(value, is_little_endian);
-                }
-
-                if (print_values) {
-                    LOG_INFO(Loader,
-                             "[IPSwitchCompiler ('{}')]     - Patching value at offset 0x{:08X} "
-                             "with byte string '{}'",
-                             patch_text->GetName(), offset, Common::HexVectorToString(replace));
-                }
-
-                patch.records.insert_or_assign(offset, std::move(replace));
-            }
-
-            patches.push_back(std::move(patch));
-        } else if (StartsWith(line, "@")) {
-            ParseFlag(line);
-        }
-    }
-
-    valid = true;
-}
-
-VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
-    if (in == nullptr || !valid)
-        return nullptr;
-
-    auto in_data = in->ReadAllBytes();
-
-    for (const auto& patch : patches) {
-        if (!patch.enabled)
-            continue;
-
-        for (const auto& record : patch.records) {
-            if (record.first >= in_data.size())
-                continue;
-            auto replace_size = record.second.size();
-            if (record.first + replace_size > in_data.size())
-                replace_size = in_data.size() - record.first;
-            for (std::size_t i = 0; i < replace_size; ++i)
-                in_data[i + record.first] = record.second[i];
-        }
-    }
-
-    return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
-                                           in->GetContainingDirectory());
+    return std::make_shared<VectorVfsFile>(in_data, in->GetName(), in->GetContainingDirectory());
 }
 
 } // namespace FileSys

src/core/file_sys/ips_layer.h

@@ -4,41 +4,12 @@
 
 #pragma once
 
-#include <array>
 #include <memory>
-#include <vector>
 
-#include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
 VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips);
 
-class IPSwitchCompiler {
-public:
-    explicit IPSwitchCompiler(VirtualFile patch_text);
-    ~IPSwitchCompiler();
-
-    std::array<u8, 0x20> GetBuildID() const;
-    bool IsValid() const;
-    VirtualFile Apply(const VirtualFile& in) const;
-
-private:
-    struct IPSwitchPatch;
-
-    void ParseFlag(const std::string& flag);
-    void Parse();
-
-    bool valid = false;
-
-    VirtualFile patch_text;
-    std::vector<IPSwitchPatch> patches;
-    std::array<u8, 0x20> nso_build_id{};
-    bool is_little_endian = false;
-    s64 offset_shift = 0;
-    bool print_values = false;
-    std::string last_comment = "";
-};
-
 } // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -73,38 +73,27 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     return exefs;
 }
 
-static std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                               const std::string& build_id) {
-    std::vector<VirtualFile> out;
-    out.reserve(patch_dirs.size());
+static std::vector<VirtualFile> CollectIPSPatches(const std::vector<VirtualDir>& patch_dirs,
+                                                  const std::string& build_id) {
+    std::vector<VirtualFile> ips;
+    ips.reserve(patch_dirs.size());
     for (const auto& subdir : patch_dirs) {
         auto exefs_dir = subdir->GetSubdirectory("exefs");
         if (exefs_dir != nullptr) {
             for (const auto& file : exefs_dir->GetFiles()) {
-                if (file->GetExtension() == "ips") {
-                    auto name = file->GetName();
-                    const auto p1 = name.substr(0, name.find('.'));
-                    const auto this_build_id = p1.substr(0, p1.find_last_not_of('0') + 1);
+                if (file->GetExtension() != "ips")
+                    continue;
+                auto name = file->GetName();
+                const auto p1 = name.substr(0, name.find('.'));
+                const auto this_build_id = p1.substr(0, p1.find_last_not_of('0') + 1);
 
-                    if (build_id == this_build_id)
-                        out.push_back(file);
-                } else if (file->GetExtension() == "pchtxt") {
-                    IPSwitchCompiler compiler{file};
-                    if (!compiler.IsValid())
-                        continue;
-
-                    auto this_build_id = Common::HexArrayToString(compiler.GetBuildID());
-                    this_build_id =
-                        this_build_id.substr(0, this_build_id.find_last_not_of('0') + 1);
-
-                    if (build_id == this_build_id)
-                        out.push_back(file);
-                }
+                if (build_id == this_build_id)
+                    ips.push_back(file);
             }
         }
     }
 
-    return out;
+    return ips;
 }
 
 std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
@@ -126,24 +115,15 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
-    const auto patches = CollectPatches(patch_dirs, build_id);
+    const auto ips = CollectIPSPatches(patch_dirs, build_id);
 
     auto out = nso;
-    for (const auto& patch_file : patches) {
-        if (patch_file->GetExtension() == "ips") {
-            LOG_INFO(Loader, "    - Applying IPS patch from mod \"{}\"",
-                     patch_file->GetContainingDirectory()->GetParentDirectory()->GetName());
-            const auto patched = PatchIPS(std::make_shared<VectorVfsFile>(out), patch_file);
-            if (patched != nullptr)
-                out = patched->ReadAllBytes();
-        } else if (patch_file->GetExtension() == "pchtxt") {
-            LOG_INFO(Loader, "    - Applying IPSwitch patch from mod \"{}\"",
-                     patch_file->GetContainingDirectory()->GetParentDirectory()->GetName());
-            const IPSwitchCompiler compiler{patch_file};
-            const auto patched = compiler.Apply(std::make_shared<VectorVfsFile>(out));
-            if (patched != nullptr)
-                out = patched->ReadAllBytes();
-        }
+    for (const auto& ips_file : ips) {
+        LOG_INFO(Loader, "    - Appling IPS patch from mod \"{}\"",
+                 ips_file->GetContainingDirectory()->GetParentDirectory()->GetName());
+        const auto patched = PatchIPS(std::make_shared<VectorVfsFile>(out), ips_file);
+        if (patched != nullptr)
+            out = patched->ReadAllBytes();
     }
 
     if (out.size() < 0x100)
@@ -163,7 +143,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
 
-    return !CollectPatches(patch_dirs, build_id).empty();
+    return !CollectIPSPatches(patch_dirs, build_id).empty();
 }
 
 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
@@ -182,17 +162,11 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
 
     std::vector<VirtualDir> layers;
-    std::vector<VirtualDir> layers_ext;
     layers.reserve(patch_dirs.size() + 1);
-    layers_ext.reserve(patch_dirs.size() + 1);
     for (const auto& subdir : patch_dirs) {
         auto romfs_dir = subdir->GetSubdirectory("romfs");
         if (romfs_dir != nullptr)
             layers.push_back(std::move(romfs_dir));
-
-        auto ext_dir = subdir->GetSubdirectory("romfs_ext");
-        if (ext_dir != nullptr)
-            layers_ext.push_back(std::move(ext_dir));
     }
     layers.push_back(std::move(extracted));
 
@@ -201,9 +175,7 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         return;
     }
 
-    auto layered_ext = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers_ext));
-
-    auto packed = CreateRomFS(std::move(layered), std::move(layered_ext));
+    auto packed = CreateRomFS(std::move(layered));
     if (packed == nullptr) {
         return;
     }
@@ -212,16 +184,10 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
     romfs = std::move(packed);
 }
 
-VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, ContentRecordType type,
-                                     VirtualFile update_raw) const {
-    const auto log_string = fmt::format("Patching RomFS for title_id={:016X}, type={:02X}",
-                                        title_id, static_cast<u8>(type))
-                                .c_str();
-
-    if (type == ContentRecordType::Program)
-        LOG_INFO(Loader, log_string);
-    else
-        LOG_DEBUG(Loader, log_string);
+VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset,
+                                     ContentRecordType type) const {
+    LOG_INFO(Loader, "Patching RomFS for title_id={:016X}, type={:02X}", title_id,
+             static_cast<u8>(type));
 
     if (romfs == nullptr)
         return romfs;
@@ -239,13 +205,6 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
                      FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
             romfs = new_nca->GetRomFS();
         }
-    } else if (update_raw != nullptr) {
-        const auto new_nca = std::make_shared<NCA>(update_raw, romfs, ivfc_offset);
-        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
-            new_nca->GetRomFS() != nullptr) {
-            LOG_INFO(Loader, "    RomFS: Update (PACKED) applied successfully");
-            romfs = new_nca->GetRomFS();
-        }
     }
 
     // LayeredFS
@@ -265,8 +224,7 @@ static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
     return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
 }
 
-std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
-    VirtualFile update_raw) const {
+std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames() const {
     std::map<std::string, std::string, std::less<>> out;
     const auto installed = Service::FileSystem::GetUnionContents();
 
@@ -287,8 +245,6 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
                     "Update",
                     FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements));
             }
-        } else if (update_raw != nullptr) {
-            out.insert_or_assign("Update", "PACKED");
         }
     }
 
@@ -297,24 +253,8 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
         for (const auto& mod : mod_dir->GetSubdirectories()) {
             std::string types;
-
-            const auto exefs_dir = mod->GetSubdirectory("exefs");
-            if (IsDirValidAndNonEmpty(exefs_dir)) {
-                bool ips = false;
-                bool ipswitch = false;
-
-                for (const auto& file : exefs_dir->GetFiles()) {
-                    if (file->GetExtension() == "ips")
-                        ips = true;
-                    else if (file->GetExtension() == "pchtxt")
-                        ipswitch = true;
-                }
-
-                if (ips)
-                    AppendCommaIfNotEmpty(types, "IPS");
-                if (ipswitch)
-                    AppendCommaIfNotEmpty(types, "IPSwitch");
-            }
+            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("exefs")))
+                AppendCommaIfNotEmpty(types, "IPS");
             if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
                 AppendCommaIfNotEmpty(types, "LayeredFS");
 
@@ -351,22 +291,23 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     return out;
 }
 
-std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
-    const auto installed{Service::FileSystem::GetUnionContents()};
+std::pair<std::shared_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
+    const auto& installed{Service::FileSystem::GetUnionContents()};
 
     const auto base_control_nca = installed->GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr)
         return {};
 
-    return ParseControlNCA(*base_control_nca);
+    return ParseControlNCA(base_control_nca);
 }
 
-std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(const NCA& nca) const {
-    const auto base_romfs = nca.GetRomFS();
+std::pair<std::shared_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(
+    const std::shared_ptr<NCA>& nca) const {
+    const auto base_romfs = nca->GetRomFS();
     if (base_romfs == nullptr)
         return {};
 
-    const auto romfs = PatchRomFS(base_romfs, nca.GetBaseIVFCOffset(), ContentRecordType::Control);
+    const auto romfs = PatchRomFS(base_romfs, nca->GetBaseIVFCOffset(), ContentRecordType::Control);
     if (romfs == nullptr)
         return {};
 
@@ -378,7 +319,7 @@ std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(cons
     if (nacp_file == nullptr)
         nacp_file = extracted->GetFile("Control.nacp");
 
-    auto nacp = nacp_file == nullptr ? nullptr : std::make_unique<NACP>(nacp_file);
+    const auto nacp = nacp_file == nullptr ? nullptr : std::make_shared<NACP>(nacp_file);
 
     VirtualFile icon_file;
     for (const auto& language : FileSys::LANGUAGE_NAMES) {
@@ -387,6 +328,6 @@ std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(cons
             break;
     }
 
-    return {std::move(nacp), icon_file};
+    return {nacp, icon_file};
 }
 } // namespace FileSys

src/core/file_sys/patch_manager.h

@@ -36,7 +36,6 @@ public:
 
     // Currently tracked NSO patches:
     // - IPS
-    // - IPSwitch
     std::vector<u8> PatchNSO(const std::vector<u8>& nso) const;
 
     // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
@@ -47,20 +46,19 @@ public:
     // - Game Updates
     // - LayeredFS
     VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
-                           ContentRecordType type = ContentRecordType::Program,
-                           VirtualFile update_raw = nullptr) const;
+                           ContentRecordType type = ContentRecordType::Program) const;
 
     // Returns a vector of pairs between patch names and patch versions.
     // i.e. Update 3.2.2 will return {"Update", "3.2.2"}
-    std::map<std::string, std::string, std::less<>> GetPatchVersionNames(
-        VirtualFile update_raw = nullptr) const;
+    std::map<std::string, std::string, std::less<>> GetPatchVersionNames() const;
 
     // Given title_id of the program, attempts to get the control data of the update and parse it,
     // falling back to the base control data.
-    std::pair<std::unique_ptr<NACP>, VirtualFile> GetControlMetadata() const;
+    std::pair<std::shared_ptr<NACP>, VirtualFile> GetControlMetadata() const;
 
     // Version of GetControlMetadata that takes an arbitrary NCA
-    std::pair<std::unique_ptr<NACP>, VirtualFile> ParseControlNCA(const NCA& nca) const;
+    std::pair<std::shared_ptr<NACP>, VirtualFile> ParseControlNCA(
+        const std::shared_ptr<NCA>& nca) const;
 
 private:
     u64 title_id;

src/core/file_sys/registered_cache.cpp

@@ -308,14 +308,14 @@ VirtualFile RegisteredCache::GetEntryRaw(RegisteredCacheEntry entry) const {
     return GetEntryRaw(entry.title_id, entry.type);
 }
 
-std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType type) const {
+std::shared_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType type) const {
     const auto raw = GetEntryRaw(title_id, type);
     if (raw == nullptr)
         return nullptr;
-    return std::make_unique<NCA>(raw);
+    return std::make_shared<NCA>(raw);
 }
 
-std::unique_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {
+std::shared_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {
     return GetEntry(entry.title_id, entry.type);
 }
 
@@ -516,7 +516,7 @@ bool RegisteredCache::RawInstallYuzuMeta(const CNMT& cnmt) {
                         }) != yuzu_meta.end();
 }
 
-RegisteredCacheUnion::RegisteredCacheUnion(std::vector<RegisteredCache*> caches)
+RegisteredCacheUnion::RegisteredCacheUnion(std::vector<std::shared_ptr<RegisteredCache>> caches)
     : caches(std::move(caches)) {}
 
 void RegisteredCacheUnion::Refresh() {
@@ -572,14 +572,14 @@ VirtualFile RegisteredCacheUnion::GetEntryRaw(RegisteredCacheEntry entry) const
     return GetEntryRaw(entry.title_id, entry.type);
 }
 
-std::unique_ptr<NCA> RegisteredCacheUnion::GetEntry(u64 title_id, ContentRecordType type) const {
+std::shared_ptr<NCA> RegisteredCacheUnion::GetEntry(u64 title_id, ContentRecordType type) const {
     const auto raw = GetEntryRaw(title_id, type);
     if (raw == nullptr)
         return nullptr;
-    return std::make_unique<NCA>(raw);
+    return std::make_shared<NCA>(raw);
 }
 
-std::unique_ptr<NCA> RegisteredCacheUnion::GetEntry(RegisteredCacheEntry entry) const {
+std::shared_ptr<NCA> RegisteredCacheUnion::GetEntry(RegisteredCacheEntry entry) const {
     return GetEntry(entry.title_id, entry.type);
 }
 

src/core/file_sys/registered_cache.h

@@ -88,8 +88,8 @@ public:
     VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
     VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
 
-    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
-    std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
+    std::shared_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
+    std::shared_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
 
     std::vector<RegisteredCacheEntry> ListEntries() const;
     // If a parameter is not boost::none, it will be filtered for from all entries.
@@ -142,7 +142,7 @@ private:
 // Combines multiple RegisteredCaches (i.e. SysNAND, UserNAND, SDMC) into one interface.
 class RegisteredCacheUnion {
 public:
-    explicit RegisteredCacheUnion(std::vector<RegisteredCache*> caches);
+    explicit RegisteredCacheUnion(std::vector<std::shared_ptr<RegisteredCache>> caches);
 
     void Refresh();
 
@@ -157,8 +157,8 @@ public:
     VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
     VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
 
-    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
-    std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
+    std::shared_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
+    std::shared_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
 
     std::vector<RegisteredCacheEntry> ListEntries() const;
     // If a parameter is not boost::none, it will be filtered for from all entries.
@@ -168,7 +168,7 @@ public:
         boost::optional<u64> title_id = boost::none) const;
 
 private:
-    std::vector<RegisteredCache*> caches;
+    std::vector<std::shared_ptr<RegisteredCache>> caches;
 };
 
 } // namespace FileSys

src/core/file_sys/romfs.cpp

@@ -129,11 +129,11 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
     return out;
 }
 
-VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
+VirtualFile CreateRomFS(VirtualDir dir) {
     if (dir == nullptr)
         return nullptr;
 
-    RomFSBuildContext ctx{dir, ext};
+    RomFSBuildContext ctx{dir};
     return ConcatenatedVfsFile::MakeConcatenatedFile(0, ctx.Build(), dir->GetName());
 }
 

src/core/file_sys/romfs.h

@@ -44,6 +44,6 @@ VirtualDir ExtractRomFS(VirtualFile file,
 
 // Converts a VFS filesystem into a RomFS binary
 // Returns nullptr on failure
-VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext = nullptr);
+VirtualFile CreateRomFS(VirtualDir dir);
 
 } // namespace FileSys

src/core/file_sys/romfs_factory.cpp

@@ -30,17 +30,12 @@ RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
 
 RomFSFactory::~RomFSFactory() = default;
 
-void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
-    this->update_raw = std::move(update_raw);
-}
-
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
     if (!updatable)
         return MakeResult<VirtualFile>(file);
 
     const PatchManager patch_manager(Core::CurrentProcess()->GetTitleID());
-    return MakeResult<VirtualFile>(
-        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
+    return MakeResult<VirtualFile>(patch_manager.PatchRomFS(file, ivfc_offset));
 }
 
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {

src/core/file_sys/romfs_factory.h

@@ -32,13 +32,11 @@ public:
     explicit RomFSFactory(Loader::AppLoader& app_loader);
     ~RomFSFactory();
 
-    void SetPackedUpdate(VirtualFile update_raw);
     ResultVal<VirtualFile> OpenCurrentProcess();
     ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);
 
 private:
     VirtualFile file;
-    VirtualFile update_raw;
     bool updatable;
     u64 ivfc_offset;
 };

src/core/file_sys/savedata_factory.cpp

@@ -51,13 +51,6 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr
                     meta.title_id);
     }
 
-    if (meta.type == SaveDataType::DeviceSaveData && meta.user_id != u128{0, 0}) {
-        LOG_WARNING(Service_FS,
-                    "Possibly incorrect SaveDataDescriptor, type is DeviceSaveData but user_id is "
-                    "non-zero ({:016X}{:016X})",
-                    meta.user_id[1], meta.user_id[0]);
-    }
-
     std::string save_directory =
         GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
@@ -99,9 +92,6 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
     case SaveDataSpaceId::NandUser:
         out = "/user/";
         break;
-    case SaveDataSpaceId::TemporaryStorage:
-        out = "/temp/";
-        break;
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
     }
@@ -110,11 +100,10 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
     case SaveDataType::SystemSaveData:
         return fmt::format("{}save/{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);
     case SaveDataType::SaveData:
-    case SaveDataType::DeviceSaveData:
         return fmt::format("{}save/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
     case SaveDataType::TemporaryStorage:
-        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+        return fmt::format("{}temp/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));

src/core/file_sys/sdmc_factory.cpp

@@ -10,10 +10,10 @@
 namespace FileSys {
 
 SDMCFactory::SDMCFactory(VirtualDir dir_)
-    : dir(std::move(dir_)), contents(std::make_unique<RegisteredCache>(
+    : dir(std::move(dir_)), contents(std::make_shared<RegisteredCache>(
                                 GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/registered"),
                                 [](const VirtualFile& file, const NcaID& id) {
-                                    return NAX{file, id}.GetDecrypted();
+                                    return std::make_shared<NAX>(file, id)->GetDecrypted();
                                 })) {}
 
 SDMCFactory::~SDMCFactory() = default;
@@ -22,8 +22,8 @@ ResultVal<VirtualDir> SDMCFactory::Open() {
     return MakeResult<VirtualDir>(dir);
 }
 
-RegisteredCache* SDMCFactory::GetSDMCContents() const {
-    return contents.get();
+std::shared_ptr<RegisteredCache> SDMCFactory::GetSDMCContents() const {
+    return contents;
 }
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -19,12 +19,12 @@ public:
     ~SDMCFactory();
 
     ResultVal<VirtualDir> Open();
-    RegisteredCache* GetSDMCContents() const;
+    std::shared_ptr<RegisteredCache> GetSDMCContents() const;
 
 private:
     VirtualDir dir;
 
-    std::unique_ptr<RegisteredCache> contents;
+    std::shared_ptr<RegisteredCache> contents;
 };
 
 } // namespace FileSys

src/core/file_sys/submission_package.cpp

@@ -259,11 +259,8 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                 auto next_nca = std::make_shared<NCA>(next_file);
                 if (next_nca->GetType() == NCAContentType::Program)
                     program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
-                if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
-                    (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
-                     (cnmt.GetTitleID() & 0x800) != 0)) {
+                if (next_nca->GetStatus() == Loader::ResultStatus::Success)
                     ncas_title[rec.type] = std::move(next_nca);
-                }
             }
 
             break;

src/core/file_sys/vfs.h

@@ -12,12 +12,20 @@
 #include <vector>
 #include <boost/optional.hpp>
 #include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
 
 namespace FileSys {
 
+class VfsDirectory;
+class VfsFile;
+class VfsFilesystem;
+
 enum class Mode : u32;
 
+// Convenience typedefs to use Vfs* interfaces
+using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;
+using VirtualDir = std::shared_ptr<VfsDirectory>;
+using VirtualFile = std::shared_ptr<VfsFile>;
+
 // An enumeration representing what can be at the end of a path in a VfsFilesystem
 enum class VfsEntryType {
     None,

src/core/file_sys/vfs_types.h

@@ -1,21 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-
-namespace FileSys {
-
-class VfsDirectory;
-class VfsFile;
-class VfsFilesystem;
-
-// Declarations for Vfs* pointer types
-
-using VirtualDir = std::shared_ptr<VfsDirectory>;
-using VirtualFile = std::shared_ptr<VfsFile>;
-using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;
-
-} // namespace FileSys

src/core/gdbstub/gdbstub.cpp

@@ -207,7 +207,7 @@ void RegisterModule(std::string name, VAddr beg, VAddr end, bool add_elf_ext) {
 
 static Kernel::Thread* FindThreadById(int id) {
     for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
-        const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+        const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
         for (auto& thread : threads) {
             if (thread->GetThreadID() == static_cast<u32>(id)) {
                 current_core = core;
@@ -597,7 +597,7 @@ static void HandleQuery() {
     } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
         std::string val = "m";
         for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
-            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
             for (const auto& thread : threads) {
                 val += fmt::format("{:x}", thread->GetThreadID());
                 val += ",";
@@ -612,7 +612,7 @@ static void HandleQuery() {
         buffer += "l<?xml version=\"1.0\"?>";
         buffer += "<threads>";
         for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
-            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
             for (const auto& thread : threads) {
                 buffer +=
                     fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",

src/core/hle/kernel/address_arbiter.cpp

@@ -39,7 +39,7 @@ static std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address)
                                            std::vector<SharedPtr<Thread>>& waiting_threads,
                                            VAddr arb_addr) {
         const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
-        const auto& thread_list = scheduler.GetThreadList();
+        const auto& thread_list = scheduler->GetThreadList();
 
         for (const auto& thread : thread_list) {
             if (thread->GetArbiterWaitAddress() == arb_addr)

src/core/hle/kernel/errors.h

@@ -22,7 +22,6 @@ enum {
     HandleTableFull = 105,
     InvalidMemoryState = 106,
     InvalidMemoryPermissions = 108,
-    InvalidMemoryRange = 110,
     InvalidThreadPriority = 112,
     InvalidProcessorId = 113,
     InvalidHandle = 114,
@@ -57,7 +56,6 @@ constexpr ResultCode ERR_INVALID_ADDRESS(ErrorModule::Kernel, ErrCodes::InvalidA
 constexpr ResultCode ERR_INVALID_ADDRESS_STATE(ErrorModule::Kernel, ErrCodes::InvalidMemoryState);
 constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS(ErrorModule::Kernel,
                                                     ErrCodes::InvalidMemoryPermissions);
-constexpr ResultCode ERR_INVALID_MEMORY_RANGE(ErrorModule::Kernel, ErrCodes::InvalidMemoryRange);
 constexpr ResultCode ERR_INVALID_HANDLE(ErrorModule::Kernel, ErrCodes::InvalidHandle);
 constexpr ResultCode ERR_INVALID_PROCESSOR_ID(ErrorModule::Kernel, ErrCodes::InvalidProcessorId);
 constexpr ResultCode ERR_INVALID_SIZE(ErrorModule::Kernel, ErrCodes::InvalidSize);

src/core/hle/kernel/kernel.cpp

@@ -116,7 +116,7 @@ struct KernelCore::Impl {
         next_thread_id = 1;
 
         process_list.clear();
-        current_process = nullptr;
+        current_process.reset();
 
         handle_table.Clear();
         resource_limits.fill(nullptr);
@@ -207,7 +207,7 @@ struct KernelCore::Impl {
 
     // Lists all processes that exist in the current session.
     std::vector<SharedPtr<Process>> process_list;
-    Process* current_process = nullptr;
+    SharedPtr<Process> current_process;
 
     Kernel::HandleTable handle_table;
     std::array<SharedPtr<ResourceLimit>, 4> resource_limits;
@@ -266,15 +266,15 @@ void KernelCore::AppendNewProcess(SharedPtr<Process> process) {
     impl->process_list.push_back(std::move(process));
 }
 
-void KernelCore::MakeCurrentProcess(Process* process) {
-    impl->current_process = process;
+void KernelCore::MakeCurrentProcess(SharedPtr<Process> process) {
+    impl->current_process = std::move(process);
 }
 
-Process* KernelCore::CurrentProcess() {
+SharedPtr<Process>& KernelCore::CurrentProcess() {
     return impl->current_process;
 }
 
-const Process* KernelCore::CurrentProcess() const {
+const SharedPtr<Process>& KernelCore::CurrentProcess() const {
     return impl->current_process;
 }
 

src/core/hle/kernel/kernel.h

@@ -66,13 +66,13 @@ public:
     void AppendNewProcess(SharedPtr<Process> process);
 
     /// Makes the given process the new current process.
-    void MakeCurrentProcess(Process* process);
+    void MakeCurrentProcess(SharedPtr<Process> process);
 
-    /// Retrieves a pointer to the current process.
-    Process* CurrentProcess();
+    /// Retrieves a reference to the current process.
+    SharedPtr<Process>& CurrentProcess();
 
-    /// Retrieves a const pointer to the current process.
-    const Process* CurrentProcess() const;
+    /// Retrieves a const reference to the current process.
+    const SharedPtr<Process>& CurrentProcess() const;
 
     /// Adds a port to the named port table
     void AddNamedPort(std::string name, SharedPtr<ClientPort> port);

src/core/hle/kernel/object.cpp

@@ -25,6 +25,7 @@ bool Object::IsWaitable() const {
     case HandleType::Process:
     case HandleType::AddressArbiter:
     case HandleType::ResourceLimit:
+    case HandleType::CodeSet:
     case HandleType::ClientPort:
     case HandleType::ClientSession:
         return false;

src/core/hle/kernel/object.h

@@ -26,6 +26,7 @@ enum class HandleType : u32 {
     AddressArbiter,
     Timer,
     ResourceLimit,
+    CodeSet,
     ClientPort,
     ServerPort,
     ClientSession,

src/core/hle/kernel/process.cpp

@@ -20,7 +20,13 @@
 
 namespace Kernel {
 
-CodeSet::CodeSet() = default;
+SharedPtr<CodeSet> CodeSet::Create(KernelCore& kernel, std::string name) {
+    SharedPtr<CodeSet> codeset(new CodeSet(kernel));
+    codeset->name = std::move(name);
+    return codeset;
+}
+
+CodeSet::CodeSet(KernelCore& kernel) : Object{kernel} {}
 CodeSet::~CodeSet() = default;
 
 SharedPtr<Process> Process::Create(KernelCore& kernel, std::string&& name) {
@@ -153,11 +159,11 @@ void Process::PrepareForTermination() {
         }
     };
 
-    const auto& system = Core::System::GetInstance();
-    stop_threads(system.Scheduler(0).GetThreadList());
-    stop_threads(system.Scheduler(1).GetThreadList());
-    stop_threads(system.Scheduler(2).GetThreadList());
-    stop_threads(system.Scheduler(3).GetThreadList());
+    auto& system = Core::System::GetInstance();
+    stop_threads(system.Scheduler(0)->GetThreadList());
+    stop_threads(system.Scheduler(1)->GetThreadList());
+    stop_threads(system.Scheduler(2)->GetThreadList());
+    stop_threads(system.Scheduler(3)->GetThreadList());
 }
 
 /**
@@ -218,20 +224,20 @@ void Process::FreeTLSSlot(VAddr tls_address) {
     tls_slots[tls_page].reset(tls_slot);
 }
 
-void Process::LoadModule(CodeSet module_, VAddr base_addr) {
+void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {
     const auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
                                 MemoryState memory_state) {
-        const auto vma = vm_manager
-                             .MapMemoryBlock(segment.addr + base_addr, module_.memory,
-                                             segment.offset, segment.size, memory_state)
-                             .Unwrap();
+        auto vma = vm_manager
+                       .MapMemoryBlock(segment.addr + base_addr, module_->memory, segment.offset,
+                                       segment.size, memory_state)
+                       .Unwrap();
         vm_manager.Reprotect(vma, permissions);
     };
 
     // Map CodeSet segments
-    MapSegment(module_.CodeSegment(), VMAPermission::ReadExecute, MemoryState::CodeStatic);
-    MapSegment(module_.RODataSegment(), VMAPermission::Read, MemoryState::CodeMutable);
-    MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeMutable);
+    MapSegment(module_->CodeSegment(), VMAPermission::ReadExecute, MemoryState::CodeStatic);
+    MapSegment(module_->RODataSegment(), VMAPermission::Read, MemoryState::CodeMutable);
+    MapSegment(module_->DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeMutable);
 }
 
 ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {

src/core/hle/kernel/process.h

@@ -24,7 +24,6 @@ class ProgramMetadata;
 namespace Kernel {
 
 class KernelCore;
-class ResourceLimit;
 
 struct AddressMapping {
     // Address and size must be page-aligned
@@ -58,33 +57,30 @@ union ProcessFlags {
     BitField<12, 1, u16> loaded_high; ///< Application loaded high (not at 0x00100000).
 };
 
-/**
- * Indicates the status of a Process instance.
- *
- * @note These match the values as used by kernel,
- *       so new entries should only be added if RE
- *       shows that a new value has been introduced.
- */
-enum class ProcessStatus {
-    Created,
-    CreatedWithDebuggerAttached,
-    Running,
-    WaitingForDebuggerToAttach,
-    DebuggerAttached,
-    Exiting,
-    Exited,
-    DebugBreak,
-};
+enum class ProcessStatus { Created, Running, Exited };
 
-struct CodeSet final {
+class ResourceLimit;
+
+struct CodeSet final : public Object {
     struct Segment {
         std::size_t offset = 0;
         VAddr addr = 0;
         u32 size = 0;
     };
 
-    explicit CodeSet();
-    ~CodeSet();
+    static SharedPtr<CodeSet> Create(KernelCore& kernel, std::string name);
+
+    std::string GetTypeName() const override {
+        return "CodeSet";
+    }
+    std::string GetName() const override {
+        return name;
+    }
+
+    static const HandleType HANDLE_TYPE = HandleType::CodeSet;
+    HandleType GetHandleType() const override {
+        return HANDLE_TYPE;
+    }
 
     Segment& CodeSegment() {
         return segments[0];
@@ -113,7 +109,14 @@ struct CodeSet final {
     std::shared_ptr<std::vector<u8>> memory;
 
     std::array<Segment, 3> segments;
-    VAddr entrypoint = 0;
+    VAddr entrypoint;
+
+    /// Name of the process
+    std::string name;
+
+private:
+    explicit CodeSet(KernelCore& kernel);
+    ~CodeSet() override;
 };
 
 class Process final : public Object {
@@ -216,7 +219,7 @@ public:
      */
     void PrepareForTermination();
 
-    void LoadModule(CodeSet module_, VAddr base_addr);
+    void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr);
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // Memory Management

src/core/hle/kernel/scheduler.cpp

@@ -9,7 +9,7 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/hle/kernel/kernel.h"
+#include "core/core_timing.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 
@@ -78,16 +78,16 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         // Cancel any outstanding wakeup events for this thread
         new_thread->CancelWakeupTimer();
 
-        auto* const previous_process = Core::CurrentProcess();
+        auto previous_process = Core::CurrentProcess();
 
         current_thread = new_thread;
 
         ready_queue.remove(new_thread->GetPriority(), new_thread);
         new_thread->SetStatus(ThreadStatus::Running);
 
-        auto* const thread_owner_process = current_thread->GetOwnerProcess();
+        const auto thread_owner_process = current_thread->GetOwnerProcess();
         if (previous_process != thread_owner_process) {
-            Core::System::GetInstance().Kernel().MakeCurrentProcess(thread_owner_process);
+            Core::CurrentProcess() = thread_owner_process;
             SetCurrentPageTable(&Core::CurrentProcess()->VMManager().page_table);
         }
 

src/core/hle/kernel/svc.cpp

@@ -8,7 +8,6 @@
 #include <mutex>
 #include <vector>
 
-#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
@@ -37,72 +36,8 @@
 
 namespace Kernel {
 namespace {
-
-// Checks if address + size is greater than the given address
-// This can return false if the size causes an overflow of a 64-bit type
-// or if the given size is zero.
-constexpr bool IsValidAddressRange(VAddr address, u64 size) {
-    return address + size > address;
-}
-
-// Checks if a given address range lies within a larger address range.
-constexpr bool IsInsideAddressRange(VAddr address, u64 size, VAddr address_range_begin,
-                                    VAddr address_range_end) {
-    const VAddr end_address = address + size - 1;
-    return address_range_begin <= address && end_address <= address_range_end - 1;
-}
-
-bool IsInsideAddressSpace(const VMManager& vm, VAddr address, u64 size) {
-    return IsInsideAddressRange(address, size, vm.GetAddressSpaceBaseAddress(),
-                                vm.GetAddressSpaceEndAddress());
-}
-
-bool IsInsideNewMapRegion(const VMManager& vm, VAddr address, u64 size) {
-    return IsInsideAddressRange(address, size, vm.GetNewMapRegionBaseAddress(),
-                                vm.GetNewMapRegionEndAddress());
-}
-
-// Helper function that performs the common sanity checks for svcMapMemory
-// and svcUnmapMemory. This is doable, as both functions perform their sanitizing
-// in the same order.
-ResultCode MapUnmapMemorySanityChecks(const VMManager& vm_manager, VAddr dst_addr, VAddr src_addr,
-                                      u64 size) {
-    if (!Common::Is4KBAligned(dst_addr) || !Common::Is4KBAligned(src_addr)) {
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (size == 0 || !Common::Is4KBAligned(size)) {
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!IsValidAddressRange(dst_addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (!IsValidAddressRange(src_addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (!IsInsideAddressSpace(vm_manager, src_addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (!IsInsideNewMapRegion(vm_manager, dst_addr, size)) {
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    const VAddr dst_end_address = dst_addr + size;
-    if (dst_end_address > vm_manager.GetHeapRegionBaseAddress() &&
-        vm_manager.GetHeapRegionEndAddress() > dst_addr) {
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    if (dst_end_address > vm_manager.GetMapRegionBaseAddress() &&
-        vm_manager.GetMapRegionEndAddress() > dst_addr) {
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return RESULT_SUCCESS;
+constexpr bool Is4KBAligned(VAddr address) {
+    return (address & 0xFFF) == 0;
 }
 } // Anonymous namespace
 
@@ -134,15 +69,15 @@ static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
-    auto* const current_process = Core::CurrentProcess();
-    const auto& vm_manager = current_process->VMManager();
-
-    const auto result = MapUnmapMemorySanityChecks(vm_manager, dst_addr, src_addr, size);
-    if (result != RESULT_SUCCESS) {
-        return result;
+    if (!Is4KBAligned(dst_addr) || !Is4KBAligned(src_addr)) {
+        return ERR_INVALID_ADDRESS;
     }
 
-    return current_process->MirrorMemory(dst_addr, src_addr, size);
+    if (size == 0 || !Is4KBAligned(size)) {
+        return ERR_INVALID_SIZE;
+    }
+
+    return Core::CurrentProcess()->MirrorMemory(dst_addr, src_addr, size);
 }
 
 /// Unmaps a region that was previously mapped with svcMapMemory
@@ -150,15 +85,15 @@ static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
-    auto* const current_process = Core::CurrentProcess();
-    const auto& vm_manager = current_process->VMManager();
-
-    const auto result = MapUnmapMemorySanityChecks(vm_manager, dst_addr, src_addr, size);
-    if (result != RESULT_SUCCESS) {
-        return result;
+    if (!Is4KBAligned(dst_addr) || !Is4KBAligned(src_addr)) {
+        return ERR_INVALID_ADDRESS;
     }
 
-    return current_process->UnmapMemory(dst_addr, src_addr, size);
+    if (size == 0 || !Is4KBAligned(size)) {
+        return ERR_INVALID_SIZE;
+    }
+
+    return Core::CurrentProcess()->UnmapMemory(dst_addr, src_addr, size);
 }
 
 /// Connect to an OS service given the port name, returns the handle to the port to out
@@ -350,10 +285,6 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    if (!Common::IsWordAligned(mutex_addr)) {
-        return ERR_INVALID_ADDRESS;
-    }
-
     auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
     return Mutex::TryAcquire(handle_table, mutex_addr, holding_thread_handle,
                              requesting_thread_handle);
@@ -367,41 +298,16 @@ static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    if (!Common::IsWordAligned(mutex_addr)) {
-        return ERR_INVALID_ADDRESS;
-    }
-
     return Mutex::Release(mutex_addr);
 }
 
-struct BreakReason {
-    union {
-        u32 raw;
-        BitField<31, 1, u32> signal_debugger;
-    };
-};
-
 /// Break program execution
-static void Break(u32 reason, u64 info1, u64 info2) {
-    BreakReason break_reason{reason};
-    if (break_reason.signal_debugger) {
-        LOG_ERROR(
-            Debug_Emulated,
-            "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
-            reason, info1, info2);
-    } else {
-        LOG_CRITICAL(
-            Debug_Emulated,
-            "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
-            reason, info1, info2);
-        ASSERT(false);
-
-        Core::CurrentProcess()->PrepareForTermination();
-
-        // Kill the current thread
-        GetCurrentThread()->Stop();
-        Core::System::GetInstance().PrepareReschedule();
-    }
+static void Break(u64 reason, u64 info1, u64 info2) {
+    LOG_CRITICAL(
+        Debug_Emulated,
+        "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
+        reason, info1, info2);
+    ASSERT(false);
 }
 
 /// Used to output a message on a debug hardware unit - does nothing on a retail unit
@@ -420,7 +326,7 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
               info_sub_id, handle);
 
-    const auto* current_process = Core::CurrentProcess();
+    const auto& current_process = Core::CurrentProcess();
     const auto& vm_manager = current_process->VMManager();
 
     switch (static_cast<GetInfoType>(info_id)) {
@@ -454,12 +360,25 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     case GetInfoType::RandomEntropy:
         *result = 0;
         break;
-    case GetInfoType::ASLRRegionBaseAddr:
-        *result = vm_manager.GetASLRRegionBaseAddress();
+    case GetInfoType::AddressSpaceBaseAddr:
+        *result = vm_manager.GetCodeRegionBaseAddress();
         break;
-    case GetInfoType::ASLRRegionSize:
-        *result = vm_manager.GetASLRRegionSize();
+    case GetInfoType::AddressSpaceSize: {
+        const u64 width = vm_manager.GetAddressSpaceWidth();
+
+        switch (width) {
+        case 32:
+            *result = 0xFFE00000;
+            break;
+        case 36:
+            *result = 0xFF8000000;
+            break;
+        case 39:
+            *result = 0x7FF8000000;
+            break;
+        }
         break;
+    }
     case GetInfoType::NewMapRegionBaseAddr:
         *result = vm_manager.GetNewMapRegionBaseAddress();
         break;
@@ -505,7 +424,7 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    const auto* current_process = Core::CurrentProcess();
+    const auto current_process = Core::CurrentProcess();
     if (thread->GetOwnerProcess() != current_process) {
         return ERR_INVALID_HANDLE;
     }
@@ -576,18 +495,14 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
               "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               shared_memory_handle, addr, size, permissions);
 
-    if (!Common::Is4KBAligned(addr)) {
+    if (!Is4KBAligned(addr)) {
         return ERR_INVALID_ADDRESS;
     }
 
-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (size == 0 || !Is4KBAligned(size)) {
         return ERR_INVALID_SIZE;
     }
 
-    if (!IsValidAddressRange(addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
     const auto permissions_type = static_cast<MemoryPermission>(permissions);
     if (permissions_type != MemoryPermission::Read &&
         permissions_type != MemoryPermission::ReadWrite) {
@@ -601,46 +516,26 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
         return ERR_INVALID_HANDLE;
     }
 
-    auto* const current_process = Core::CurrentProcess();
-    const auto& vm_manager = current_process->VMManager();
-
-    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return shared_memory->Map(current_process, addr, permissions_type, MemoryPermission::DontCare);
+    return shared_memory->Map(Core::CurrentProcess().get(), addr, permissions_type,
+                              MemoryPermission::DontCare);
 }
 
 static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size) {
     LOG_WARNING(Kernel_SVC, "called, shared_memory_handle=0x{:08X}, addr=0x{:X}, size=0x{:X}",
                 shared_memory_handle, addr, size);
 
-    if (!Common::Is4KBAligned(addr)) {
+    if (!Is4KBAligned(addr)) {
         return ERR_INVALID_ADDRESS;
     }
 
-    if (size == 0 || !Common::Is4KBAligned(size)) {
+    if (size == 0 || !Is4KBAligned(size)) {
         return ERR_INVALID_SIZE;
     }
 
-    if (!IsValidAddressRange(addr, size)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
     auto& kernel = Core::System::GetInstance().Kernel();
     auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
-    if (!shared_memory) {
-        return ERR_INVALID_HANDLE;
-    }
 
-    auto* const current_process = Core::CurrentProcess();
-    const auto& vm_manager = current_process->VMManager();
-
-    if (!vm_manager.IsWithinASLRRegion(addr, size)) {
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return shared_memory->Unmap(current_process, addr);
+    return shared_memory->Unmap(Core::CurrentProcess().get(), addr);
 }
 
 /// Query process memory
@@ -654,7 +549,7 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_i
     }
     auto vma = process->VMManager().FindVMA(addr);
     memory_info->attributes = 0;
-    if (vma == process->VMManager().vma_map.end()) {
+    if (vma == Core::CurrentProcess()->VMManager().vma_map.end()) {
         memory_info->base_address = 0;
         memory_info->permission = static_cast<u32>(VMAPermission::None);
         memory_info->size = 0;
@@ -678,7 +573,7 @@ static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAdd
 
 /// Exits the current process
 static void ExitProcess() {
-    auto* current_process = Core::CurrentProcess();
+    auto& current_process = Core::CurrentProcess();
 
     LOG_INFO(Kernel_SVC, "Process {} exiting", current_process->GetProcessID());
     ASSERT_MSG(current_process->GetStatus() == ProcessStatus::Running,
@@ -726,7 +621,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     auto& kernel = Core::System::GetInstance().Kernel();
     CASCADE_RESULT(SharedPtr<Thread> thread,
                    Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
-                                  *Core::CurrentProcess()));
+                                  Core::CurrentProcess()));
     const auto new_guest_handle = kernel.HandleTable().Create(thread);
     if (new_guest_handle.Failed()) {
         return new_guest_handle.Code();
@@ -826,7 +721,7 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
                                            std::vector<SharedPtr<Thread>>& waiting_threads,
                                            VAddr condvar_addr) {
         const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
-        const auto& thread_list = scheduler.GetThreadList();
+        const auto& thread_list = scheduler->GetThreadList();
 
         for (const auto& thread : thread_list) {
             if (thread->GetCondVarWaitAddress() == condvar_addr)
@@ -1115,29 +1010,6 @@ static ResultCode ClearEvent(Handle handle) {
     return RESULT_SUCCESS;
 }
 
-static ResultCode GetProcessInfo(u64* out, Handle process_handle, u32 type) {
-    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, type=0x{:X}", process_handle, type);
-
-    // This function currently only allows retrieving a process' status.
-    enum class InfoType {
-        Status,
-    };
-
-    const auto& kernel = Core::System::GetInstance().Kernel();
-    const auto process = kernel.HandleTable().Get<Process>(process_handle);
-    if (!process) {
-        return ERR_INVALID_HANDLE;
-    }
-
-    const auto info_type = static_cast<InfoType>(type);
-    if (info_type != InfoType::Status) {
-        return ERR_INVALID_ENUM_VALUE;
-    }
-
-    *out = static_cast<u64>(process->GetStatus());
-    return RESULT_SUCCESS;
-}
-
 namespace {
 struct FunctionDef {
     using Func = void();
@@ -1273,7 +1145,7 @@ static const FunctionDef SVC_Table[] = {
     {0x79, nullptr, "CreateProcess"},
     {0x7A, nullptr, "StartProcess"},
     {0x7B, nullptr, "TerminateProcess"},
-    {0x7C, SvcWrap<GetProcessInfo>, "GetProcessInfo"},
+    {0x7C, nullptr, "GetProcessInfo"},
     {0x7D, nullptr, "CreateResourceLimit"},
     {0x7E, nullptr, "SetResourceLimitLimitValue"},
     {0x7F, nullptr, "CallSecureMonitor"},

src/core/hle/kernel/svc.h

@@ -41,8 +41,8 @@ enum class GetInfoType : u64 {
     RandomEntropy = 11,
     PerformanceCounter = 0xF0000002,
     // 2.0.0+
-    ASLRRegionBaseAddr = 12,
-    ASLRRegionSize = 13,
+    AddressSpaceBaseAddr = 12,
+    AddressSpaceSize = 13,
     NewMapRegionBaseAddr = 14,
     NewMapRegionSize = 15,
     // 3.0.0+

src/core/hle/kernel/svc_wrap.h

@@ -35,18 +35,18 @@ void SvcWrap() {
 
 template <ResultCode func(u32)>
 void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0))).raw);
+    FuncReturn(func((u32)Param(0)).raw);
 }
 
 template <ResultCode func(u32, u32)>
 void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), static_cast<u32>(Param(1))).raw);
+    FuncReturn(func((u32)Param(0), (u32)Param(1)).raw);
 }
 
 template <ResultCode func(u32*, u32)>
 void SvcWrap() {
     u32 param_1 = 0;
-    u32 retval = func(&param_1, static_cast<u32>(Param(1))).raw;
+    u32 retval = func(&param_1, (u32)Param(1)).raw;
     Core::CurrentArmInterface().SetReg(1, param_1);
     FuncReturn(retval);
 }
@@ -61,7 +61,7 @@ void SvcWrap() {
 
 template <ResultCode func(u64, s32)>
 void SvcWrap() {
-    FuncReturn(func(Param(0), static_cast<s32>(Param(1))).raw);
+    FuncReturn(func(Param(0), (s32)Param(1)).raw);
 }
 
 template <ResultCode func(u64, u32)>
@@ -77,29 +77,21 @@ void SvcWrap() {
     FuncReturn(retval);
 }
 
-template <ResultCode func(u64*, u32, u32)>
-void SvcWrap() {
-    u64 param_1 = 0;
-    u32 retval = func(&param_1, static_cast<u32>(Param(1)), static_cast<u32>(Param(2))).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
-}
-
 template <ResultCode func(u32, u64)>
 void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), Param(1)).raw);
+    FuncReturn(func((u32)(Param(0) & 0xFFFFFFFF), Param(1)).raw);
 }
 
 template <ResultCode func(u32, u32, u64)>
 void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), static_cast<u32>(Param(1)), Param(2)).raw);
+    FuncReturn(func((u32)(Param(0) & 0xFFFFFFFF), (u32)(Param(1) & 0xFFFFFFFF), Param(2)).raw);
 }
 
 template <ResultCode func(u32, u32*, u64*)>
 void SvcWrap() {
     u32 param_1 = 0;
     u64 param_2 = 0;
-    ResultCode retval = func(static_cast<u32>(Param(2)), &param_1, &param_2);
+    ResultCode retval = func((u32)(Param(2) & 0xFFFFFFFF), &param_1, &param_2);
     Core::CurrentArmInterface().SetReg(1, param_1);
     Core::CurrentArmInterface().SetReg(2, param_2);
     FuncReturn(retval.raw);
@@ -108,12 +100,12 @@ void SvcWrap() {
 template <ResultCode func(u64, u64, u32, u32)>
 void SvcWrap() {
     FuncReturn(
-        func(Param(0), Param(1), static_cast<u32>(Param(3)), static_cast<u32>(Param(3))).raw);
+        func(Param(0), Param(1), (u32)(Param(3) & 0xFFFFFFFF), (u32)(Param(3) & 0xFFFFFFFF)).raw);
 }
 
 template <ResultCode func(u32, u64, u32)>
 void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), Param(1), static_cast<u32>(Param(2))).raw);
+    FuncReturn(func((u32)Param(0), Param(1), (u32)Param(2)).raw);
 }
 
 template <ResultCode func(u64, u64, u64)>
@@ -123,28 +115,25 @@ void SvcWrap() {
 
 template <ResultCode func(u32, u64, u64, u32)>
 void SvcWrap() {
-    FuncReturn(
-        func(static_cast<u32>(Param(0)), Param(1), Param(2), static_cast<u32>(Param(3))).raw);
+    FuncReturn(func((u32)Param(0), Param(1), Param(2), (u32)Param(3)).raw);
 }
 
 template <ResultCode func(u32, u64, u64)>
 void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), Param(1), Param(2)).raw);
+    FuncReturn(func((u32)Param(0), Param(1), Param(2)).raw);
 }
 
 template <ResultCode func(u32*, u64, u64, s64)>
 void SvcWrap() {
     u32 param_1 = 0;
-    ResultCode retval =
-        func(&param_1, Param(1), static_cast<u32>(Param(2)), static_cast<s64>(Param(3)));
+    ResultCode retval = func(&param_1, Param(1), (u32)(Param(2) & 0xFFFFFFFF), (s64)Param(3));
     Core::CurrentArmInterface().SetReg(1, param_1);
     FuncReturn(retval.raw);
 }
 
 template <ResultCode func(u64, u64, u32, s64)>
 void SvcWrap() {
-    FuncReturn(
-        func(Param(0), Param(1), static_cast<u32>(Param(2)), static_cast<s64>(Param(3))).raw);
+    FuncReturn(func(Param(0), Param(1), (u32)Param(2), (s64)Param(3)).raw);
 }
 
 template <ResultCode func(u64*, u64, u64, u64)>
@@ -158,9 +147,9 @@ void SvcWrap() {
 template <ResultCode func(u32*, u64, u64, u64, u32, s32)>
 void SvcWrap() {
     u32 param_1 = 0;
-    u32 retval = func(&param_1, Param(1), Param(2), Param(3), static_cast<u32>(Param(4)),
-                      static_cast<s32>(Param(5)))
-                     .raw;
+    u32 retval =
+        func(&param_1, Param(1), Param(2), Param(3), (u32)Param(4), (s32)(Param(5) & 0xFFFFFFFF))
+            .raw;
     Core::CurrentArmInterface().SetReg(1, param_1);
     FuncReturn(retval);
 }
@@ -183,7 +172,7 @@ void SvcWrap() {
 template <ResultCode func(u32*, u64, u64, u32)>
 void SvcWrap() {
     u32 param_1 = 0;
-    u32 retval = func(&param_1, Param(1), Param(2), static_cast<u32>(Param(3))).raw;
+    u32 retval = func(&param_1, Param(1), Param(2), (u32)(Param(3) & 0xFFFFFFFF)).raw;
     Core::CurrentArmInterface().SetReg(1, param_1);
     FuncReturn(retval);
 }
@@ -192,22 +181,22 @@ template <ResultCode func(Handle*, u64, u32, u32)>
 void SvcWrap() {
     u32 param_1 = 0;
     u32 retval =
-        func(&param_1, Param(1), static_cast<u32>(Param(2)), static_cast<u32>(Param(3))).raw;
+        func(&param_1, Param(1), (u32)(Param(2) & 0xFFFFFFFF), (u32)(Param(3) & 0xFFFFFFFF)).raw;
     Core::CurrentArmInterface().SetReg(1, param_1);
     FuncReturn(retval);
 }
 
 template <ResultCode func(u64, u32, s32, s64)>
 void SvcWrap() {
-    FuncReturn(func(Param(0), static_cast<u32>(Param(1)), static_cast<s32>(Param(2)),
-                    static_cast<s64>(Param(3)))
-                   .raw);
+    FuncReturn(
+        func(Param(0), (u32)(Param(1) & 0xFFFFFFFF), (s32)(Param(2) & 0xFFFFFFFF), (s64)Param(3))
+            .raw);
 }
 
 template <ResultCode func(u64, u32, s32, s32)>
 void SvcWrap() {
-    FuncReturn(func(Param(0), static_cast<u32>(Param(1)), static_cast<s32>(Param(2)),
-                    static_cast<s32>(Param(3)))
+    FuncReturn(func(Param(0), (u32)(Param(1) & 0xFFFFFFFF), (s32)(Param(2) & 0xFFFFFFFF),
+                    (s32)(Param(3) & 0xFFFFFFFF))
                    .raw);
 }
 
@@ -237,7 +226,7 @@ void SvcWrap() {
 
 template <void func(s64)>
 void SvcWrap() {
-    func(static_cast<s64>(Param(0)));
+    func((s64)Param(0));
 }
 
 template <void func(u64, u64 len)>
@@ -250,9 +239,4 @@ void SvcWrap() {
     func(Param(0), Param(1), Param(2));
 }
 
-template <void func(u32, u64, u64)>
-void SvcWrap() {
-    func(static_cast<u32>(Param(0)), Param(1), Param(2));
-}
-
 } // namespace Kernel

src/core/hle/kernel/thread.cpp

@@ -97,7 +97,7 @@ void Thread::CancelWakeupTimer() {
 static boost::optional<s32> GetNextProcessorId(u64 mask) {
     for (s32 index = 0; index < Core::NUM_CPU_CORES; ++index) {
         if (mask & (1ULL << index)) {
-            if (!Core::System::GetInstance().Scheduler(index).GetCurrentThread()) {
+            if (!Core::System::GetInstance().Scheduler(index)->GetCurrentThread()) {
                 // Core is enabled and not running any threads, use this one
                 return index;
             }
@@ -147,14 +147,14 @@ void Thread::ResumeFromWait() {
         new_processor_id = processor_id;
     }
     if (ideal_core != -1 &&
-        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+        Core::System::GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
         new_processor_id = ideal_core;
     }
 
     ASSERT(*new_processor_id < 4);
 
     // Add thread to new core's scheduler
-    auto* next_scheduler = &Core::System::GetInstance().Scheduler(*new_processor_id);
+    auto& next_scheduler = Core::System::GetInstance().Scheduler(*new_processor_id);
 
     if (*new_processor_id != processor_id) {
         // Remove thread from previous core's scheduler
@@ -169,7 +169,7 @@ void Thread::ResumeFromWait() {
     next_scheduler->ScheduleThread(this, current_priority);
 
     // Change thread's scheduler
-    scheduler = next_scheduler;
+    scheduler = next_scheduler.get();
 
     Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }
@@ -183,15 +183,18 @@ void Thread::ResumeFromWait() {
  */
 static void ResetThreadContext(Core::ARM_Interface::ThreadContext& context, VAddr stack_top,
                                VAddr entry_point, u64 arg) {
-    context = {};
+    memset(&context, 0, sizeof(Core::ARM_Interface::ThreadContext));
+
     context.cpu_registers[0] = arg;
     context.pc = entry_point;
     context.sp = stack_top;
+    context.pstate = 0;
+    context.fpcr = 0;
 }
 
 ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name, VAddr entry_point,
                                             u32 priority, u64 arg, s32 processor_id,
-                                            VAddr stack_top, Process& owner_process) {
+                                            VAddr stack_top, SharedPtr<Process> owner_process) {
     // Check if priority is in ranged. Lowest priority -> highest priority id.
     if (priority > THREADPRIO_LOWEST) {
         LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
@@ -205,7 +208,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
 
     // TODO(yuriks): Other checks, returning 0xD9001BEA
 
-    if (!Memory::IsValidVirtualAddress(owner_process, entry_point)) {
+    if (!Memory::IsValidVirtualAddress(*owner_process, entry_point)) {
         LOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
         // TODO (bunnei): Find the correct error code to use here
         return ResultCode(-1);
@@ -229,8 +232,8 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->wait_handle = 0;
     thread->name = std::move(name);
     thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
-    thread->owner_process = &owner_process;
-    thread->scheduler = &Core::System::GetInstance().Scheduler(processor_id);
+    thread->owner_process = owner_process;
+    thread->scheduler = Core::System::GetInstance().Scheduler(processor_id).get();
     thread->scheduler->AddThread(thread, priority);
     thread->tls_address = thread->owner_process->MarkNextAvailableTLSSlotAsUsed(*thread);
 
@@ -261,7 +264,7 @@ SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 pri
     // Initialize new "main" thread
     const VAddr stack_top = owner_process.VMManager().GetTLSIORegionEndAddress();
     auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0, THREADPROCESSORID_0,
-                                     stack_top, owner_process);
+                                     stack_top, &owner_process);
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
@@ -375,14 +378,14 @@ void Thread::ChangeCore(u32 core, u64 mask) {
         new_processor_id = processor_id;
     }
     if (ideal_core != -1 &&
-        Core::System::GetInstance().Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+        Core::System::GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
         new_processor_id = ideal_core;
     }
 
     ASSERT(*new_processor_id < 4);
 
     // Add thread to new core's scheduler
-    auto* next_scheduler = &Core::System::GetInstance().Scheduler(*new_processor_id);
+    auto& next_scheduler = Core::System::GetInstance().Scheduler(*new_processor_id);
 
     if (*new_processor_id != processor_id) {
         // Remove thread from previous core's scheduler
@@ -397,7 +400,7 @@ void Thread::ChangeCore(u32 core, u64 mask) {
     next_scheduler->ScheduleThread(this, current_priority);
 
     // Change thread's scheduler
-    scheduler = next_scheduler;
+    scheduler = next_scheduler.get();
 
     Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }

src/core/hle/kernel/thread.h

@@ -89,7 +89,7 @@ public:
     static ResultVal<SharedPtr<Thread>> Create(KernelCore& kernel, std::string name,
                                                VAddr entry_point, u32 priority, u64 arg,
                                                s32 processor_id, VAddr stack_top,
-                                               Process& owner_process);
+                                               SharedPtr<Process> owner_process);
 
     std::string GetName() const override {
         return name;
@@ -262,11 +262,11 @@ public:
         return processor_id;
     }
 
-    Process* GetOwnerProcess() {
+    SharedPtr<Process>& GetOwnerProcess() {
         return owner_process;
     }
 
-    const Process* GetOwnerProcess() const {
+    const SharedPtr<Process>& GetOwnerProcess() const {
         return owner_process;
     }
 
@@ -386,7 +386,7 @@ private:
     u64 tpidr_el0 = 0;     ///< TPIDR_EL0 read/write system register.
 
     /// Process that owns this thread
-    Process* owner_process;
+    SharedPtr<Process> owner_process;
 
     /// Objects that the thread is waiting on, in the same order as they were
     /// passed to WaitSynchronization1/N.

src/core/hle/kernel/vm_manager.cpp

@@ -393,35 +393,30 @@ void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType ty
 
     switch (type) {
     case FileSys::ProgramAddressSpaceType::Is32Bit:
-    case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
         address_space_width = 32;
         code_region_base = 0x200000;
         code_region_end = code_region_base + 0x3FE00000;
-        aslr_region_base = 0x200000;
-        aslr_region_end = aslr_region_base + 0xFFE00000;
-        if (type == FileSys::ProgramAddressSpaceType::Is32Bit) {
-            map_region_size = 0x40000000;
-            heap_region_size = 0x40000000;
-        } else {
-            map_region_size = 0;
-            heap_region_size = 0x80000000;
-        }
+        map_region_size = 0x40000000;
+        heap_region_size = 0x40000000;
         break;
     case FileSys::ProgramAddressSpaceType::Is36Bit:
         address_space_width = 36;
         code_region_base = 0x8000000;
         code_region_end = code_region_base + 0x78000000;
-        aslr_region_base = 0x8000000;
-        aslr_region_end = aslr_region_base + 0xFF8000000;
         map_region_size = 0x180000000;
         heap_region_size = 0x180000000;
         break;
+    case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
+        address_space_width = 32;
+        code_region_base = 0x200000;
+        code_region_end = code_region_base + 0x3FE00000;
+        map_region_size = 0;
+        heap_region_size = 0x80000000;
+        break;
     case FileSys::ProgramAddressSpaceType::Is39Bit:
         address_space_width = 39;
         code_region_base = 0x8000000;
         code_region_end = code_region_base + 0x80000000;
-        aslr_region_base = 0x8000000;
-        aslr_region_end = aslr_region_base + 0x7FF8000000;
         map_region_size = 0x1000000000;
         heap_region_size = 0x180000000;
         new_map_region_size = 0x80000000;
@@ -495,38 +490,6 @@ u64 VMManager::GetAddressSpaceWidth() const {
     return address_space_width;
 }
 
-VAddr VMManager::GetASLRRegionBaseAddress() const {
-    return aslr_region_base;
-}
-
-VAddr VMManager::GetASLRRegionEndAddress() const {
-    return aslr_region_end;
-}
-
-u64 VMManager::GetASLRRegionSize() const {
-    return aslr_region_end - aslr_region_base;
-}
-
-bool VMManager::IsWithinASLRRegion(VAddr begin, u64 size) const {
-    const VAddr range_end = begin + size;
-    const VAddr aslr_start = GetASLRRegionBaseAddress();
-    const VAddr aslr_end = GetASLRRegionEndAddress();
-
-    if (aslr_start > begin || begin > range_end || range_end - 1 > aslr_end - 1) {
-        return false;
-    }
-
-    if (range_end > heap_region_base && heap_region_end > begin) {
-        return false;
-    }
-
-    if (range_end > map_region_base && map_region_end > begin) {
-        return false;
-    }
-
-    return true;
-}
-
 VAddr VMManager::GetCodeRegionBaseAddress() const {
     return code_region_base;
 }

src/core/hle/kernel/vm_manager.h

@@ -205,18 +205,6 @@ public:
     /// Gets the address space width in bits.
     u64 GetAddressSpaceWidth() const;
 
-    /// Gets the base address of the ASLR region.
-    VAddr GetASLRRegionBaseAddress() const;
-
-    /// Gets the end address of the ASLR region.
-    VAddr GetASLRRegionEndAddress() const;
-
-    /// Determines whether or not the specified address range is within the ASLR region.
-    bool IsWithinASLRRegion(VAddr address, u64 size) const;
-
-    /// Gets the size of the ASLR region
-    u64 GetASLRRegionSize() const;
-
     /// Gets the base address of the code region.
     VAddr GetCodeRegionBaseAddress() const;
 
@@ -318,9 +306,6 @@ private:
     VAddr address_space_base = 0;
     VAddr address_space_end = 0;
 
-    VAddr aslr_region_base = 0;
-    VAddr aslr_region_end = 0;
-
     VAddr code_region_base = 0;
     VAddr code_region_end = 0;
 

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

@@ -15,7 +15,6 @@
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
-#include "core/hle/service/am/tcap.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -27,18 +26,13 @@
 namespace Service::AM {
 
 IWindowController::IWindowController() : ServiceFramework("IWindowController") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateWindow"},
         {1, &IWindowController::GetAppletResourceUserId, "GetAppletResourceUserId"},
         {10, &IWindowController::AcquireForegroundRights, "AcquireForegroundRights"},
         {11, nullptr, "ReleaseForegroundRights"},
         {12, nullptr, "RejectToChangeIntoBackground"},
-        {20, nullptr, "SetAppletWindowVisibility"},
-        {21, nullptr, "SetAppletGpuTimeSlice"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
@@ -93,7 +87,6 @@ void IAudioController::GetLibraryAppletExpectedMasterVolume(Kernel::HLERequestCo
 }
 
 IDisplayController::IDisplayController() : ServiceFramework("IDisplayController") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetLastForegroundCaptureImage"},
         {1, nullptr, "UpdateLastForegroundCaptureImage"},
@@ -124,11 +117,7 @@ IDisplayController::IDisplayController() : ServiceFramework("IDisplayController"
         {25, nullptr, "ReleaseLastForegroundCaptureSharedBuffer"},
         {26, nullptr, "AcquireCallerAppletCaptureSharedBuffer"},
         {27, nullptr, "ReleaseCallerAppletCaptureSharedBuffer"},
-        // 6.0.0+
-        {28, nullptr, "TakeScreenShotOfOwnLayerEx"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
@@ -139,7 +128,6 @@ IDebugFunctions::~IDebugFunctions() = default;
 
 ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "Exit"},
         {1, &ISelfController::LockExit, "LockExit"},
@@ -148,8 +136,10 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {4, nullptr, "LeaveFatalSection"},
         {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
         {10, &ISelfController::SetScreenShotPermission, "SetScreenShotPermission"},
-        {11, &ISelfController::SetOperationModeChangedNotification, "SetOperationModeChangedNotification"},
-        {12, &ISelfController::SetPerformanceModeChangedNotification, "SetPerformanceModeChangedNotification"},
+        {11, &ISelfController::SetOperationModeChangedNotification,
+         "SetOperationModeChangedNotification"},
+        {12, &ISelfController::SetPerformanceModeChangedNotification,
+         "SetPerformanceModeChangedNotification"},
         {13, &ISelfController::SetFocusHandlingMode, "SetFocusHandlingMode"},
         {14, &ISelfController::SetRestartMessageEnabled, "SetRestartMessageEnabled"},
         {15, nullptr, "SetScreenShotAppletIdentityInfo"},
@@ -175,12 +165,7 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {69, nullptr, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
         {80, nullptr, "SetWirelessPriorityMode"},
-        {90, nullptr, "GetAccumulatedSuspendedTickValue"},
-        {91, nullptr, "GetAccumulatedSuspendedTickChangedEvent"},
-        {1000, nullptr, "GetDebugStorageChannel"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -327,7 +312,6 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
 }
 
 ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
         {1, &ICommonStateGetter::ReceiveMessage, "ReceiveMessage"},
@@ -352,12 +336,11 @@ ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter"
         {52, nullptr, "SwitchLcdBacklight"},
         {55, nullptr, "IsInControllerFirmwareUpdateSection"},
         {60, &ICommonStateGetter::GetDefaultDisplayResolution, "GetDefaultDisplayResolution"},
-        {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent, "GetDefaultDisplayResolutionChangeEvent"},
+        {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent,
+         "GetDefaultDisplayResolutionChangeEvent"},
         {62, nullptr, "GetHdcpAuthenticationState"},
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -449,14 +432,11 @@ class IStorageAccessor final : public ServiceFramework<IStorageAccessor> {
 public:
     explicit IStorageAccessor(std::vector<u8> buffer)
         : ServiceFramework("IStorageAccessor"), buffer(std::move(buffer)) {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IStorageAccessor::GetSize, "GetSize"},
             {10, &IStorageAccessor::Write, "Write"},
             {11, &IStorageAccessor::Read, "Read"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 
@@ -509,13 +489,10 @@ class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(std::vector<u8> buffer)
         : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IStorage::Open, "Open"},
             {1, nullptr, "OpenTransferStorage"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 
@@ -535,7 +512,6 @@ private:
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
 public:
     explicit ILibraryAppletAccessor() : ServiceFramework("ILibraryAppletAccessor") {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletAccessor::GetAppletStateChangedEvent, "GetAppletStateChangedEvent"},
             {1, nullptr, "IsCompleted"},
@@ -556,8 +532,6 @@ public:
             {150, nullptr, "RequestForAppletToGetForeground"},
             {160, nullptr, "GetIndirectLayerConsumerHandle"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
@@ -650,13 +624,13 @@ void ILibraryAppletCreator::CreateStorage(Kernel::HLERequestContext& ctx) {
 }
 
 IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
         {10, nullptr, "CreateApplicationAndPushAndRequestToStart"},
         {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
         {12, nullptr, "CreateApplicationAndRequestToStart"},
-        {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest, "CreateApplicationAndRequestToStartForQuest"},
+        {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest,
+         "CreateApplicationAndRequestToStartForQuest"},
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
@@ -664,10 +638,10 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {24, nullptr, "GetLaunchStorageInfoForDebug"},
         {25, nullptr, "ExtendSaveData"},
         {26, nullptr, "GetSaveDataSize"},
-        {30, &IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed, "BeginBlockingHomeButtonShortAndLongPressed"},
-        {31, &IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed, "EndBlockingHomeButtonShortAndLongPressed"},
-        {32, &IApplicationFunctions::BeginBlockingHomeButton, "BeginBlockingHomeButton"},
-        {33, &IApplicationFunctions::EndBlockingHomeButton, "EndBlockingHomeButton"},
+        {30, nullptr, "BeginBlockingHomeButtonShortAndLongPressed"},
+        {31, nullptr, "EndBlockingHomeButtonShortAndLongPressed"},
+        {32, nullptr, "BeginBlockingHomeButton"},
+        {33, nullptr, "EndBlockingHomeButton"},
         {40, &IApplicationFunctions::NotifyRunning, "NotifyRunning"},
         {50, &IApplicationFunctions::GetPseudoDeviceId, "GetPseudoDeviceId"},
         {60, nullptr, "SetMediaPlaybackStateForApplication"},
@@ -690,39 +664,11 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {1000, nullptr, "CreateMovieMaker"},
         {1001, nullptr, "PrepareForJit"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
 IApplicationFunctions::~IApplicationFunctions() = default;
 
-void IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed(
-    Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed(
-    Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void IApplicationFunctions::BeginBlockingHomeButton(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
-void IApplicationFunctions::EndBlockingHomeButton(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-}
-
 void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
     constexpr std::array<u8, 0x88> data{{
         0xca, 0x97, 0x94, 0xc7, // Magic
@@ -830,11 +776,9 @@ void InstallInterfaces(SM::ServiceManager& service_manager,
     std::make_shared<IdleSys>()->InstallAsService(service_manager);
     std::make_shared<OMM>()->InstallAsService(service_manager);
     std::make_shared<SPSM>()->InstallAsService(service_manager);
-    std::make_shared<TCAP>()->InstallAsService(service_manager);
 }
 
 IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {10, &IHomeMenuFunctions::RequestToGetForeground, "RequestToGetForeground"},
         {11, nullptr, "LockForeground"},
@@ -843,10 +787,7 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
         {21, nullptr, "GetPopFromGeneralChannelEvent"},
         {30, nullptr, "GetHomeButtonWriterLockAccessor"},
         {31, nullptr, "GetWriterLockAccessorEx"},
-        {100, nullptr, "PopRequestLaunchApplicationForDebug"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
@@ -859,7 +800,6 @@ void IHomeMenuFunctions::RequestToGetForeground(Kernel::HLERequestContext& ctx)
 }
 
 IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStateController") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "RequestToEnterSleep"},
         {1, nullptr, "EnterSleep"},
@@ -873,23 +813,18 @@ IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStat
         {14, nullptr, "ShouldSleepOnBoot"},
         {15, nullptr, "GetHdcpAuthenticationFailedEvent"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
 IGlobalStateController::~IGlobalStateController() = default;
 
 IApplicationCreator::IApplicationCreator() : ServiceFramework("IApplicationCreator") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CreateApplication"},
         {1, nullptr, "PopLaunchRequestedApplication"},
         {10, nullptr, "CreateSystemApplication"},
         {100, nullptr, "PopFloatingApplicationForDevelopment"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 
@@ -897,7 +832,6 @@ IApplicationCreator::~IApplicationCreator() = default;
 
 IProcessWindingController::IProcessWindingController()
     : ServiceFramework("IProcessWindingController") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetLaunchReason"},
         {11, nullptr, "OpenCallingLibraryApplet"},
@@ -908,8 +842,6 @@ IProcessWindingController::IProcessWindingController()
         {40, nullptr, "ReserveToStartAndWaitAndUnwindThis"},
         {41, nullptr, "ReserveToStartAndWait"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -154,10 +154,6 @@ private:
     void SetGamePlayRecordingState(Kernel::HLERequestContext& ctx);
     void NotifyRunning(Kernel::HLERequestContext& ctx);
     void GetPseudoDeviceId(Kernel::HLERequestContext& ctx);
-    void BeginBlockingHomeButtonShortAndLongPressed(Kernel::HLERequestContext& ctx);
-    void EndBlockingHomeButtonShortAndLongPressed(Kernel::HLERequestContext& ctx);
-    void BeginBlockingHomeButton(Kernel::HLERequestContext& ctx);
-    void EndBlockingHomeButton(Kernel::HLERequestContext& ctx);
 };
 
 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {

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

@@ -211,7 +211,6 @@ void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
 
 AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
     : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)) {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},
         {200, &AppletAE::OpenLibraryAppletProxyOld, "OpenLibraryAppletProxyOld"},
@@ -219,10 +218,7 @@ AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         {300, nullptr, "OpenOverlayAppletProxy"},
         {350, nullptr, "OpenSystemApplicationProxy"},
         {400, nullptr, "CreateSelfLibraryAppletCreatorForDevelop"},
-        {401, nullptr, "GetSystemAppletControllerForDebug"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -14,7 +14,6 @@ class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
     explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)) {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IApplicationProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &IApplicationProxy::GetSelfController, "GetSelfController"},
@@ -26,8 +25,6 @@ public:
             {20, &IApplicationProxy::GetApplicationFunctions, "GetApplicationFunctions"},
             {1000, &IApplicationProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 

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

@@ -12,9 +12,9 @@ IdleSys::IdleSys() : ServiceFramework{"idle:sys"} {
         {0, nullptr, "GetAutoPowerDownEvent"},
         {1, nullptr, "Unknown1"},
         {2, nullptr, "Unknown2"},
-        {3, nullptr, "SetHandlingContext"},
-        {4, nullptr, "LoadAndApplySettings"},
-        {5, nullptr, "ReportUserIsActive"},
+        {3, nullptr, "Unknown3"},
+        {4, nullptr, "Unknown4"},
+        {5, nullptr, "Unknown5"},
     };
     // clang-format on
 

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

@@ -17,24 +17,22 @@ OMM::OMM() : ServiceFramework{"omm"} {
         {5, nullptr, "GetCradleStatus"},
         {6, nullptr, "FadeInDisplay"},
         {7, nullptr, "FadeOutDisplay"},
-        {8, nullptr, "GetCradleFwVersion"},
-        {9, nullptr, "NotifyCecSettingsChanged"},
-        {10, nullptr, "SetOperationModePolicy"},
-        {11, nullptr, "GetDefaultDisplayResolution"},
-        {12, nullptr, "GetDefaultDisplayResolutionChangeEvent"},
-        {13, nullptr, "UpdateDefaultDisplayResolution"},
-        {14, nullptr, "ShouldSleepOnBoot"},
-        {15, nullptr, "NotifyHdcpApplicationExecutionStarted"},
-        {16, nullptr, "NotifyHdcpApplicationExecutionFinished"},
-        {17, nullptr, "NotifyHdcpApplicationDrawingStarted"},
-        {18, nullptr, "NotifyHdcpApplicationDrawingFinished"},
-        {19, nullptr, "GetHdcpAuthenticationFailedEvent"},
-        {20, nullptr, "GetHdcpAuthenticationFailedEmulationEnabled"},
-        {21, nullptr, "SetHdcpAuthenticationFailedEmulation"},
-        {22, nullptr, "GetHdcpStateChangeEvent"},
-        {23, nullptr, "GetHdcpState"},
-        {24, nullptr, "ShowCardUpdateProcessing"},
-        {25, nullptr, "SetApplicationCecSettingsAndNotifyChanged"},
+        {8, nullptr, "Unknown1"},
+        {9, nullptr, "Unknown2"},
+        {10, nullptr, "Unknown3"},
+        {11, nullptr, "Unknown4"},
+        {12, nullptr, "Unknown5"},
+        {13, nullptr, "Unknown6"},
+        {14, nullptr, "Unknown7"},
+        {15, nullptr, "Unknown8"},
+        {16, nullptr, "Unknown9"},
+        {17, nullptr, "Unknown10"},
+        {18, nullptr, "Unknown11"},
+        {19, nullptr, "Unknown12"},
+        {20, nullptr, "Unknown13"},
+        {21, nullptr, "Unknown14"},
+        {22, nullptr, "Unknown15"},
+        {23, nullptr, "Unknown16"},
     };
     // clang-format on
 

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

@@ -1,23 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/am/tcap.h"
-
-namespace Service::AM {
-
-TCAP::TCAP() : ServiceFramework{"tcap"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetContinuousHighSkinTemperatureEvent"},
-        {1, nullptr, "SetOperationMode"},
-        {2, nullptr, "LoadAndApplySettings"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-TCAP::~TCAP() = default;
-
-} // namespace Service::AM

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

@@ -1,17 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service::AM {
-
-class TCAP final : public ServiceFramework<TCAP> {
-public:
-    explicit TCAP();
-    ~TCAP() override;
-};
-
-} // namespace Service::AM

src/core/hle/service/aoc/aoc_u.cpp

@@ -7,13 +7,10 @@
 #include <vector>
 #include "common/logging/log.h"
 #include "core/file_sys/content_archive.h"
-#include "core/file_sys/control_metadata.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/aoc/aoc_u.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -22,7 +19,7 @@
 namespace Service::AOC {
 
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
-constexpr u64 DLC_BASE_TO_AOC_ID = 0x1000;
+constexpr u64 DLC_BASE_TO_AOC_ID_MASK = 0x1000;
 
 static bool CheckAOCTitleIDMatchesBase(u64 base, u64 aoc) {
     return (aoc & DLC_BASE_TITLE_ID_MASK) == base;
@@ -56,25 +53,21 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
         {5, &AOC_U::GetAddOnContentBaseId, "GetAddOnContentBaseId"},
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
-        {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
+        {8, nullptr, "GetAddOnContentListChangedEvent"},
     };
     RegisterHandlers(functions);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    aoc_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::Sticky,
-                                             "GetAddOnContentListChanged:Event");
 }
 
 AOC_U::~AOC_U() = default;
 
 void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
 
     const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-    rb.Push<u32>(static_cast<u32>(
-        std::count_if(add_on_content.begin(), add_on_content.end(),
-                      [&current](u64 tid) { return (tid & DLC_BASE_TITLE_ID_MASK) == current; })));
+    rb.Push<u32>(std::count_if(add_on_content.begin(), add_on_content.end(), [&current](u64 tid) {
+        return (tid & DLC_BASE_TITLE_ID_MASK) == current;
+    }));
 }
 
 void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
@@ -98,30 +91,20 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
+    count = std::min<size_t>(out.size() - offset, count);
     std::rotate(out.begin(), out.begin() + offset, out.end());
     out.resize(count);
 
     ctx.WriteBuffer(out);
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(count);
 }
 
 void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    const auto title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-    FileSys::PatchManager pm{title_id};
-
-    const auto res = pm.GetControlMetadata();
-    if (res.first == nullptr) {
-        rb.Push(title_id + DLC_BASE_TO_AOC_ID);
-        return;
-    }
-
-    rb.Push(res.first->GetDLCBaseTitleId());
+    rb.Push(Core::System::GetInstance().CurrentProcess()->GetTitleID() | DLC_BASE_TO_AOC_ID_MASK);
 }
 
 void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
@@ -135,14 +118,6 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AOC, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(aoc_change_event);
-}
-
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AOC_U>()->InstallAsService(service_manager);
 }

src/core/hle/service/aoc/aoc_u.h

@@ -18,10 +18,8 @@ private:
     void ListAddOnContent(Kernel::HLERequestContext& ctx);
     void GetAddOnContentBaseId(Kernel::HLERequestContext& ctx);
     void PrepareAddOnContent(Kernel::HLERequestContext& ctx);
-    void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
 
     std::vector<u64> add_on_content;
-    Kernel::SharedPtr<Kernel::Event> aoc_change_event;
 };
 
 /// Registers all AOC services with the specified service manager.

src/core/hle/service/audio/audren_u.cpp

@@ -22,22 +22,20 @@ class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
     explicit IAudioRenderer(AudioCore::AudioRendererParameter audren_params)
         : ServiceFramework("IAudioRenderer") {
-        // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &IAudioRenderer::GetSampleRate, "GetSampleRate"},
-            {1, &IAudioRenderer::GetSampleCount, "GetSampleCount"},
-            {2, &IAudioRenderer::GetMixBufferCount, "GetMixBufferCount"},
-            {3, &IAudioRenderer::GetState, "GetState"},
-            {4, &IAudioRenderer::RequestUpdate, "RequestUpdate"},
-            {5, &IAudioRenderer::Start, "Start"},
-            {6, &IAudioRenderer::Stop, "Stop"},
+            {0, &IAudioRenderer::GetAudioRendererSampleRate, "GetAudioRendererSampleRate"},
+            {1, &IAudioRenderer::GetAudioRendererSampleCount, "GetAudioRendererSampleCount"},
+            {2, &IAudioRenderer::GetAudioRendererMixBufferCount, "GetAudioRendererMixBufferCount"},
+            {3, &IAudioRenderer::GetAudioRendererState, "GetAudioRendererState"},
+            {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
+            {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
+            {6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
             {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
-            {8, nullptr, "SetRenderingTimeLimit"},
-            {9, nullptr, "GetRenderingTimeLimit"},
-            {10, nullptr, "RequestUpdateAuto"},
+            {8, nullptr, "SetAudioRendererRenderingTimeLimit"},
+            {9, nullptr, "GetAudioRendererRenderingTimeLimit"},
+            {10, nullptr, "RequestUpdateAudioRendererAuto"},
             {11, nullptr, "ExecuteAudioRendererRendering"},
         };
-        // clang-format on
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
@@ -51,42 +49,42 @@ private:
         system_event->Signal();
     }
 
-    void GetSampleRate(Kernel::HLERequestContext& ctx) {
+    void GetAudioRendererSampleRate(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetSampleRate());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetSampleCount(Kernel::HLERequestContext& ctx) {
+    void GetAudioRendererSampleCount(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetSampleCount());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetState(Kernel::HLERequestContext& ctx) {
+    void GetAudioRendererState(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(static_cast<u32>(renderer->GetStreamState()));
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void GetMixBufferCount(Kernel::HLERequestContext& ctx) {
+    void GetAudioRendererMixBufferCount(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(renderer->GetMixBufferCount());
         LOG_DEBUG(Service_Audio, "called");
     }
 
-    void RequestUpdate(Kernel::HLERequestContext& ctx) {
+    void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
         ctx.WriteBuffer(renderer->UpdateAudioRenderer(ctx.ReadBuffer()));
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
-    void Start(Kernel::HLERequestContext& ctx) {
+    void StartAudioRenderer(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
 
         rb.Push(RESULT_SUCCESS);
@@ -94,7 +92,7 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
     }
 
-    void Stop(Kernel::HLERequestContext& ctx) {
+    void StopAudioRenderer(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 2};
 
         rb.Push(RESULT_SUCCESS);
@@ -131,7 +129,6 @@ public:
             {10, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
             {11, nullptr, "QueryAudioDeviceInputEvent"},
             {12, nullptr, "QueryAudioDeviceOutputEvent"},
-            {13, nullptr, "GetAudioSystemMasterVolumeSetting"},
         };
         RegisterHandlers(functions);
 

src/core/hle/service/audio/hwopus.cpp

@@ -2,10 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <chrono>
 #include <cstring>
 #include <memory>
-#include <optional>
 #include <vector>
 
 #include <opus.h>
@@ -35,8 +33,7 @@ public:
             {1, nullptr, "SetContext"},
             {2, nullptr, "DecodeInterleavedForMultiStream"},
             {3, nullptr, "SetContextForMultiStream"},
-            {4, &IHardwareOpusDecoderManager::DecodeInterleavedWithPerformance,
-             "DecodeInterleavedWithPerformance"},
+            {4, nullptr, "Unknown4"},
             {5, nullptr, "Unknown5"},
             {6, nullptr, "Unknown6"},
             {7, nullptr, "Unknown7"},
@@ -62,31 +59,8 @@ private:
         ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
     }
 
-    void DecodeInterleavedWithPerformance(Kernel::HLERequestContext& ctx) {
-        u32 consumed = 0;
-        u32 sample_count = 0;
-        u64 performance = 0;
-        std::vector<opus_int16> samples(ctx.GetWriteBufferSize() / sizeof(opus_int16));
-        if (!Decoder_DecodeInterleaved(consumed, sample_count, ctx.ReadBuffer(), samples,
-                                       performance)) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            // TODO(ogniK): Use correct error code
-            rb.Push(ResultCode(-1));
-            return;
-        }
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(consumed);
-        rb.Push<u64>(performance);
-        rb.Push<u32>(sample_count);
-        ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
-    }
-
-    bool Decoder_DecodeInterleaved(
-        u32& consumed, u32& sample_count, const std::vector<u8>& input,
-        std::vector<opus_int16>& output,
-        std::optional<std::reference_wrapper<u64>> performance_time = std::nullopt) {
-        const auto start_time = std::chrono::high_resolution_clock::now();
+    bool Decoder_DecodeInterleaved(u32& consumed, u32& sample_count, const std::vector<u8>& input,
+                                   std::vector<opus_int16>& output) {
         std::size_t raw_output_sz = output.size() * sizeof(opus_int16);
         if (sizeof(OpusHeader) > input.size())
             return false;
@@ -106,13 +80,8 @@ private:
                         (static_cast<int>(raw_output_sz / sizeof(s16) / channel_count)), 0);
         if (out_sample_count < 0)
             return false;
-        const auto end_time = std::chrono::high_resolution_clock::now() - start_time;
         sample_count = out_sample_count;
         consumed = static_cast<u32>(sizeof(OpusHeader) + hdr.sz);
-        if (performance_time.has_value()) {
-            performance_time->get() =
-                std::chrono::duration_cast<std::chrono::milliseconds>(end_time).count();
-        }
         return true;
     }
 

src/core/hle/service/es/es.cpp

@@ -9,7 +9,6 @@ namespace Service::ES {
 class ETicket final : public ServiceFramework<ETicket> {
 public:
     explicit ETicket() : ServiceFramework{"es"} {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {1, nullptr, "ImportTicket"},
             {2, nullptr, "ImportTicketCertificateSet"},
@@ -38,18 +37,15 @@ public:
             {25, nullptr, "DeletePrepurchaseRecord"},
             {26, nullptr, "DeleteAllPrepurchaseRecord"},
             {27, nullptr, "CountPrepurchaseRecord"},
-            {28, nullptr, "ListPrepurchaseRecordRightsIds"},
+            {28, nullptr, "ListPrepurchaseRecord"},
             {29, nullptr, "ListPrepurchaseRecordInfo"},
-            {30, nullptr, "CountTicket"},
-            {31, nullptr, "ListTicketRightsIds"},
-            {32, nullptr, "CountPrepurchaseRecordEx"},
-            {33, nullptr, "ListPrepurchaseRecordRightsIdsEx"},
-            {34, nullptr, "GetEncryptedTicketSize"},
-            {35, nullptr, "GetEncryptedTicketData"},
-            {36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
-            {503, nullptr, "GetTitleKey"},
+            {30, nullptr, "Unknown1"},
+            {31, nullptr, "Unknown2"},
+            {32, nullptr, "Unknown3"},
+            {33, nullptr, "Unknown4"},
+            {34, nullptr, "Unknown5"},
+            {35, nullptr, "Unknown6"},
         };
-        // clang-format on
         RegisterHandlers(functions);
     }
 };

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

@@ -264,15 +264,6 @@ ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
     return RESULT_SUCCESS;
 }
 
-void SetPackedUpdate(FileSys::VirtualFile update_raw) {
-    LOG_TRACE(Service_FS, "Setting packed update for romfs");
-
-    if (romfs_factory == nullptr)
-        return;
-
-    romfs_factory->SetPackedUpdate(std::move(update_raw));
-}
-
 ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() {
     LOG_TRACE(Service_FS, "Opening RomFS for current process");
 
@@ -319,12 +310,13 @@ ResultVal<FileSys::VirtualDir> OpenSDMC() {
     return sdmc_factory->Open();
 }
 
-std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
-    return std::make_unique<FileSys::RegisteredCacheUnion>(std::vector<FileSys::RegisteredCache*>{
-        GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
+std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents() {
+    return std::make_shared<FileSys::RegisteredCacheUnion>(
+        std::vector<std::shared_ptr<FileSys::RegisteredCache>>{
+            GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()});
 }
 
-FileSys::RegisteredCache* GetSystemNANDContents() {
+std::shared_ptr<FileSys::RegisteredCache> GetSystemNANDContents() {
     LOG_TRACE(Service_FS, "Opening System NAND Contents");
 
     if (bis_factory == nullptr)
@@ -333,7 +325,7 @@ FileSys::RegisteredCache* GetSystemNANDContents() {
     return bis_factory->GetSystemNANDContents();
 }
 
-FileSys::RegisteredCache* GetUserNANDContents() {
+std::shared_ptr<FileSys::RegisteredCache> GetUserNANDContents() {
     LOG_TRACE(Service_FS, "Opening User NAND Contents");
 
     if (bis_factory == nullptr)
@@ -342,7 +334,7 @@ FileSys::RegisteredCache* GetUserNANDContents() {
     return bis_factory->GetUserNANDContents();
 }
 
-FileSys::RegisteredCache* GetSDMCContents() {
+std::shared_ptr<FileSys::RegisteredCache> GetSDMCContents() {
     LOG_TRACE(Service_FS, "Opening SDMC Contents");
 
     if (sdmc_factory == nullptr)
@@ -360,19 +352,19 @@ FileSys::VirtualDir GetModificationLoadRoot(u64 title_id) {
     return bis_factory->GetModificationLoadRoot(title_id);
 }
 
-void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
+void CreateFactories(const FileSys::VirtualFilesystem& vfs, bool overwrite) {
     if (overwrite) {
         bis_factory = nullptr;
         save_data_factory = nullptr;
         sdmc_factory = nullptr;
     }
 
-    auto nand_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir),
-                                            FileSys::Mode::ReadWrite);
-    auto sd_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir),
-                                          FileSys::Mode::ReadWrite);
-    auto load_directory = vfs.OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::LoadDir),
-                                            FileSys::Mode::ReadWrite);
+    auto nand_directory = vfs->OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir),
+                                             FileSys::Mode::ReadWrite);
+    auto sd_directory = vfs->OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir),
+                                           FileSys::Mode::ReadWrite);
+    auto load_directory = vfs->OpenDirectory(FileUtil::GetUserPath(FileUtil::UserPath::LoadDir),
+                                             FileSys::Mode::ReadWrite);
 
     if (bis_factory == nullptr)
         bis_factory = std::make_unique<FileSys::BISFactory>(nand_directory, load_directory);
@@ -382,7 +374,7 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
         sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager, FileSys::VfsFilesystem& vfs) {
+void InstallInterfaces(SM::ServiceManager& service_manager, const FileSys::VirtualFilesystem& vfs) {
     romfs_factory = nullptr;
     CreateFactories(vfs, false);
     std::make_shared<FSP_LDR>()->InstallAsService(service_manager);

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

@@ -39,7 +39,6 @@ ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory)
 ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
 ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
 
-void SetPackedUpdate(FileSys::VirtualFile update_raw);
 ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess();
 ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
                                           FileSys::ContentRecordType type);
@@ -47,19 +46,19 @@ ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
                                             FileSys::SaveDataDescriptor save_struct);
 ResultVal<FileSys::VirtualDir> OpenSDMC();
 
-std::unique_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
+std::shared_ptr<FileSys::RegisteredCacheUnion> GetUnionContents();
 
-FileSys::RegisteredCache* GetSystemNANDContents();
-FileSys::RegisteredCache* GetUserNANDContents();
-FileSys::RegisteredCache* GetSDMCContents();
+std::shared_ptr<FileSys::RegisteredCache> GetSystemNANDContents();
+std::shared_ptr<FileSys::RegisteredCache> GetUserNANDContents();
+std::shared_ptr<FileSys::RegisteredCache> GetSDMCContents();
 
 FileSys::VirtualDir GetModificationLoadRoot(u64 title_id);
 
 // Creates the SaveData, SDMC, and BIS Factories. Should be called once and before any function
 // above is called.
-void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite = true);
+void CreateFactories(const FileSys::VirtualFilesystem& vfs, bool overwrite = true);
 
-void InstallInterfaces(SM::ServiceManager& service_manager, FileSys::VfsFilesystem& vfs);
+void InstallInterfaces(SM::ServiceManager& service_manager, const FileSys::VirtualFilesystem& vfs);
 
 // A class that wraps a VfsDirectory with methods that return ResultVal and ResultCode instead of
 // pointers and booleans. This makes using a VfsDirectory with switch services much easier and

src/core/hle/service/hid/controllers/controller_base.cpp

@@ -1,30 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/hid/controllers/controller_base.h"
-
-namespace Service::HID {
-
-ControllerBase::ControllerBase() = default;
-ControllerBase::~ControllerBase() = default;
-
-void ControllerBase::ActivateController() {
-    if (is_activated) {
-        OnRelease();
-    }
-    is_activated = true;
-    OnInit();
-}
-
-void ControllerBase::DeactivateController() {
-    if (is_activated) {
-        OnRelease();
-    }
-    is_activated = false;
-}
-
-bool ControllerBase::IsControllerActivated() const {
-    return is_activated;
-}
-} // namespace Service::HID

src/core/hle/service/hid/controllers/controller_base.h

@@ -1,45 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "common/swap.h"
-
-namespace Service::HID {
-class ControllerBase {
-public:
-    ControllerBase();
-    virtual ~ControllerBase();
-
-    // Called when the controller is initialized
-    virtual void OnInit() = 0;
-
-    // When the controller is released
-    virtual void OnRelease() = 0;
-
-    // When the controller is requesting an update for the shared memory
-    virtual void OnUpdate(u8* data, std::size_t size) = 0;
-
-    // Called when input devices should be loaded
-    virtual void OnLoadInputDevices() = 0;
-
-    void ActivateController();
-
-    void DeactivateController();
-
-    bool IsControllerActivated() const;
-
-protected:
-    bool is_activated{false};
-
-    struct CommonHeader {
-        s64_le timestamp;
-        s64_le total_entry_count;
-        s64_le last_entry_index;
-        s64_le entry_count;
-    };
-    static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");
-};
-} // namespace Service::HID

src/core/hle/service/hid/controllers/debug_pad.cpp

@@ -1,42 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/common_types.h"
-#include "core/core_timing.h"
-#include "core/hle/service/hid/controllers/debug_pad.h"
-
-namespace Service::HID {
-
-Controller_DebugPad::Controller_DebugPad() = default;
-Controller_DebugPad::~Controller_DebugPad() = default;
-
-void Controller_DebugPad::OnInit() {}
-
-void Controller_DebugPad::OnRelease() {}
-
-void Controller_DebugPad::OnUpdate(u8* data, std::size_t size) {
-    shared_memory.header.timestamp = CoreTiming::GetTicks();
-    shared_memory.header.total_entry_count = 17;
-
-    if (!IsControllerActivated()) {
-        shared_memory.header.entry_count = 0;
-        shared_memory.header.last_entry_index = 0;
-        return;
-    }
-    shared_memory.header.entry_count = 16;
-
-    const auto& last_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
-    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
-    auto& cur_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
-
-    cur_entry.sampling_number = last_entry.sampling_number + 1;
-    cur_entry.sampling_number2 = cur_entry.sampling_number;
-    // TODO(ogniK): Update debug pad states
-
-    std::memcpy(data, &shared_memory, sizeof(SharedMemory));
-}
-
-void Controller_DebugPad::OnLoadInputDevices() {}
-} // namespace Service::HID

src/core/hle/service/hid/controllers/debug_pad.h

@@ -1,56 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
-
-namespace Service::HID {
-class Controller_DebugPad final : public ControllerBase {
-public:
-    Controller_DebugPad();
-    ~Controller_DebugPad() override;
-
-    // Called when the controller is initialized
-    void OnInit() override;
-
-    // When the controller is released
-    void OnRelease() override;
-
-    // When the controller is requesting an update for the shared memory
-    void OnUpdate(u8* data, std::size_t size) override;
-
-    // Called when input devices should be loaded
-    void OnLoadInputDevices() override;
-
-private:
-    struct AnalogStick {
-        s32_le x;
-        s32_le y;
-    };
-    static_assert(sizeof(AnalogStick) == 0x8);
-
-    struct PadStates {
-        s64_le sampling_number;
-        s64_le sampling_number2;
-        u32_le attribute;
-        u32_le button_state;
-        AnalogStick r_stick;
-        AnalogStick l_stick;
-    };
-    static_assert(sizeof(PadStates) == 0x28, "PadStates is an invalid state");
-
-    struct SharedMemory {
-        CommonHeader header;
-        std::array<PadStates, 17> pad_states;
-        INSERT_PADDING_BYTES(0x138);
-    };
-    static_assert(sizeof(SharedMemory) == 0x400, "SharedMemory is an invalid size");
-    SharedMemory shared_memory{};
-};
-} // namespace Service::HID

src/core/hle/service/hid/controllers/gesture.cpp

@@ -1,43 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/common_types.h"
-#include "core/core_timing.h"
-#include "core/hle/service/hid/controllers/gesture.h"
-
-namespace Service::HID {
-constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3BA00;
-
-Controller_Gesture::Controller_Gesture() = default;
-Controller_Gesture::~Controller_Gesture() = default;
-
-void Controller_Gesture::OnInit() {}
-
-void Controller_Gesture::OnRelease() {}
-
-void Controller_Gesture::OnUpdate(u8* data, std::size_t size) {
-    shared_memory.header.timestamp = CoreTiming::GetTicks();
-    shared_memory.header.total_entry_count = 17;
-
-    if (!IsControllerActivated()) {
-        shared_memory.header.entry_count = 0;
-        shared_memory.header.last_entry_index = 0;
-        return;
-    }
-    shared_memory.header.entry_count = 16;
-
-    const auto& last_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
-    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
-    auto& cur_entry = shared_memory.gesture_states[shared_memory.header.last_entry_index];
-
-    cur_entry.sampling_number = last_entry.sampling_number + 1;
-    cur_entry.sampling_number2 = cur_entry.sampling_number;
-    // TODO(ogniK): Update gesture states
-
-    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
-}
-
-void Controller_Gesture::OnLoadInputDevices() {}
-} // namespace Service::HID

src/core/hle/service/hid/controllers/gesture.h

@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
-
-namespace Service::HID {
-class Controller_Gesture final : public ControllerBase {
-public:
-    Controller_Gesture();
-    ~Controller_Gesture() override;
-
-    // Called when the controller is initialized
-    void OnInit() override;
-
-    // When the controller is released
-    void OnRelease() override;
-
-    // When the controller is requesting an update for the shared memory
-    void OnUpdate(u8* data, size_t size) override;
-
-    // Called when input devices should be loaded
-    void OnLoadInputDevices() override;
-
-private:
-    struct Locations {
-        s32_le x;
-        s32_le y;
-    };
-
-    struct GestureState {
-        s64_le sampling_number;
-        s64_le sampling_number2;
-
-        s64_le detection_count;
-        s32_le type;
-        s32_le dir;
-        s32_le x;
-        s32_le y;
-        s32_le delta_x;
-        s32_le delta_y;
-        f32 vel_x;
-        f32 vel_y;
-        s32_le attributes;
-        f32 scale;
-        f32 rotation;
-        s32_le location_count;
-        std::array<Locations, 4> locations;
-    };
-    static_assert(sizeof(GestureState) == 0x68, "GestureState is an invalid size");
-
-    struct SharedMemory {
-        CommonHeader header;
-        std::array<GestureState, 17> gesture_states;
-    };
-    SharedMemory shared_memory{};
-};
-} // namespace Service::HID

src/core/hle/service/hid/controllers/keyboard.cpp

@@ -1,43 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/common_types.h"
-#include "core/core_timing.h"
-#include "core/hle/service/hid/controllers/keyboard.h"
-
-namespace Service::HID {
-constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
-
-Controller_Keyboard::Controller_Keyboard() = default;
-Controller_Keyboard::~Controller_Keyboard() = default;
-
-void Controller_Keyboard::OnInit() {}
-
-void Controller_Keyboard::OnRelease() {}
-
-void Controller_Keyboard::OnUpdate(u8* data, std::size_t size) {
-    shared_memory.header.timestamp = CoreTiming::GetTicks();
-    shared_memory.header.total_entry_count = 17;
-
-    if (!IsControllerActivated()) {
-        shared_memory.header.entry_count = 0;
-        shared_memory.header.last_entry_index = 0;
-        return;
-    }
-    shared_memory.header.entry_count = 16;
-
-    const auto& last_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
-    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
-    auto& cur_entry = shared_memory.pad_states[shared_memory.header.last_entry_index];
-
-    cur_entry.sampling_number = last_entry.sampling_number + 1;
-    cur_entry.sampling_number2 = cur_entry.sampling_number;
-    // TODO(ogniK): Update keyboard states
-
-    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
-}
-
-void Controller_Keyboard::OnLoadInputDevices() {}
-} // namespace Service::HID

src/core/hle/service/hid/controllers/keyboard.h

@@ -1,50 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
-
-namespace Service::HID {
-class Controller_Keyboard final : public ControllerBase {
-public:
-    Controller_Keyboard();
-    ~Controller_Keyboard() override;
-
-    // Called when the controller is initialized
-    void OnInit() override;
-
-    // When the controller is released
-    void OnRelease() override;
-
-    // When the controller is requesting an update for the shared memory
-    void OnUpdate(u8* data, std::size_t size) override;
-
-    // Called when input devices should be loaded
-    void OnLoadInputDevices() override;
-
-private:
-    struct KeyboardState {
-        s64_le sampling_number;
-        s64_le sampling_number2;
-
-        s32_le modifier;
-        s32_le attribute;
-        std::array<u8, 32> key;
-    };
-    static_assert(sizeof(KeyboardState) == 0x38, "KeyboardState is an invalid size");
-
-    struct SharedMemory {
-        CommonHeader header;
-        std::array<KeyboardState, 17> pad_states;
-        INSERT_PADDING_BYTES(0x28);
-    };
-    static_assert(sizeof(SharedMemory) == 0x400, "SharedMemory is an invalid size");
-    SharedMemory shared_memory{};
-};
-} // namespace Service::HID

src/core/hle/service/hid/controllers/mouse.cpp

@@ -1,43 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/common_types.h"
-#include "core/core_timing.h"
-#include "core/hle/service/hid/controllers/mouse.h"
-
-namespace Service::HID {
-constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400;
-
-Controller_Mouse::Controller_Mouse() = default;
-Controller_Mouse::~Controller_Mouse() = default;
-
-void Controller_Mouse::OnInit() {}
-
-void Controller_Mouse::OnRelease() {}
-
-void Controller_Mouse::OnUpdate(u8* data, std::size_t size) {
-    shared_memory.header.timestamp = CoreTiming::GetTicks();
-    shared_memory.header.total_entry_count = 17;
-
-    if (!IsControllerActivated()) {
-        shared_memory.header.entry_count = 0;
-        shared_memory.header.last_entry_index = 0;
-        return;
-    }
-    shared_memory.header.entry_count = 16;
-
-    auto& last_entry = shared_memory.mouse_states[shared_memory.header.last_entry_index];
-    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
-    auto& cur_entry = shared_memory.mouse_states[shared_memory.header.last_entry_index];
-
-    cur_entry.sampling_number = last_entry.sampling_number + 1;
-    cur_entry.sampling_number2 = cur_entry.sampling_number;
-    // TODO(ogniK): Update mouse states
-
-    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(SharedMemory));
-}
-
-void Controller_Mouse::OnLoadInputDevices() {}
-} // namespace Service::HID

src/core/hle/service/hid/controllers/mouse.h

@@ -1,50 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
-
-namespace Service::HID {
-class Controller_Mouse final : public ControllerBase {
-public:
-    Controller_Mouse();
-    ~Controller_Mouse() override;
-
-    // Called when the controller is initialized
-    void OnInit() override;
-
-    // When the controller is released
-    void OnRelease() override;
-
-    // When the controller is requesting an update for the shared memory
-    void OnUpdate(u8* data, std::size_t size) override;
-
-    // Called when input devices should be loaded
-    void OnLoadInputDevices() override;
-
-private:
-    struct MouseState {
-        s64_le sampling_number;
-        s64_le sampling_number2;
-        s32_le x;
-        s32_le y;
-        s32_le delta_x;
-        s32_le delta_y;
-        s32_le mouse_wheel;
-        s32_le button;
-        s32_le attribute;
-    };
-    static_assert(sizeof(MouseState) == 0x30, "MouseState is an invalid size");
-
-    struct SharedMemory {
-        CommonHeader header;
-        std::array<MouseState, 17> mouse_states;
-    };
-    SharedMemory shared_memory{};
-};
-} // namespace Service::HID

src/core/hle/service/hid/controllers/npad.cpp

@@ -1,619 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-#include "common/assert.h"
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/frontend/input.h"
-#include "core/hle/kernel/event.h"
-#include "core/hle/service/hid/controllers/npad.h"
-#include "core/settings.h"
-
-namespace Service::HID {
-
-constexpr u32 JOYCON_BODY_NEON_RED = 0xFF3C28;
-constexpr u32 JOYCON_BUTTONS_NEON_RED = 0x1E0A0A;
-constexpr u32 JOYCON_BODY_NEON_BLUE = 0x0AB9E6;
-constexpr u32 JOYCON_BUTTONS_NEON_BLUE = 0x001E1E;
-constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
-constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
-constexpr std::size_t NPAD_OFFSET = 0x9A00;
-constexpr u32 BATTERY_FULL = 2;
-constexpr u32 NPAD_HANDHELD = 32;
-constexpr u32 NPAD_UNKNOWN = 16; // TODO(ogniK): What is this?
-constexpr u32 MAX_NPAD_ID = 7;
-constexpr Controller_NPad::NPadControllerType PREFERRED_CONTROLLER =
-    Controller_NPad::NPadControllerType::JoyDual;
-constexpr std::array<u32, 10> npad_id_list{
-    0, 1, 2, 3, 4, 5, 6, 7, 32, 16,
-};
-
-enum class JoystickId : std::size_t {
-    Joystick_Left,
-    Joystick_Right,
-};
-
-Controller_NPad::Controller_NPad() = default;
-Controller_NPad::~Controller_NPad() = default;
-
-void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
-    const auto controller_type = connected_controllers[controller_idx].type;
-    auto& controller = shared_memory_entries[controller_idx];
-    if (controller_type == NPadControllerType::None) {
-        return;
-    }
-    controller.joy_styles.raw = 0; // Zero out
-    controller.device_type.raw = 0;
-    switch (controller_type) {
-    case NPadControllerType::Handheld:
-        controller.joy_styles.handheld.Assign(1);
-        controller.device_type.handheld.Assign(1);
-        controller.pad_assignment = NPadAssignments::Dual;
-        break;
-    case NPadControllerType::JoyDual:
-        controller.joy_styles.joycon_dual.Assign(1);
-        controller.device_type.joycon_left.Assign(1);
-        controller.device_type.joycon_right.Assign(1);
-        controller.pad_assignment = NPadAssignments::Dual;
-        break;
-    case NPadControllerType::JoyLeft:
-        controller.joy_styles.joycon_left.Assign(1);
-        controller.device_type.joycon_left.Assign(1);
-        controller.pad_assignment = NPadAssignments::Dual;
-        break;
-    case NPadControllerType::JoyRight:
-        controller.joy_styles.joycon_right.Assign(1);
-        controller.device_type.joycon_right.Assign(1);
-        controller.pad_assignment = NPadAssignments::Dual;
-        break;
-    case NPadControllerType::Pokeball:
-        controller.joy_styles.pokeball.Assign(1);
-        controller.device_type.pokeball.Assign(1);
-        controller.pad_assignment = NPadAssignments::Single;
-        break;
-    case NPadControllerType::ProController:
-        controller.joy_styles.pro_controller.Assign(1);
-        controller.device_type.pro_controller.Assign(1);
-        controller.pad_assignment = NPadAssignments::Single;
-        break;
-    }
-
-    controller.single_color_error = ColorReadError::ReadOk;
-    controller.single_color.body_color = 0;
-    controller.single_color.button_color = 0;
-
-    controller.dual_color_error = ColorReadError::ReadOk;
-    controller.left_color.body_color = JOYCON_BODY_NEON_BLUE;
-    controller.left_color.button_color = JOYCON_BUTTONS_NEON_BLUE;
-    controller.right_color.body_color = JOYCON_BODY_NEON_RED;
-    controller.right_color.button_color = JOYCON_BUTTONS_NEON_RED;
-
-    controller.properties.is_vertical.Assign(1); // TODO(ogniK): Swap joycons orientations
-    controller.properties.use_plus.Assign(1);
-    controller.properties.use_minus.Assign(1);
-    controller.battery_level[0] = BATTERY_FULL;
-    controller.battery_level[1] = BATTERY_FULL;
-    controller.battery_level[2] = BATTERY_FULL;
-}
-
-void Controller_NPad::OnInit() {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    styleset_changed_event =
-        Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");
-
-    if (!IsControllerActivated())
-        return;
-    std::size_t controller{};
-    if (style.raw == 0) {
-        // We want to support all controllers
-        style.handheld.Assign(1);
-        style.joycon_left.Assign(1);
-        style.joycon_right.Assign(1);
-        style.joycon_dual.Assign(1);
-        style.pro_controller.Assign(1);
-        style.pokeball.Assign(1);
-    }
-    if (std::none_of(connected_controllers.begin(), connected_controllers.end(),
-                     [](const ControllerHolder& controller) { return controller.is_connected; })) {
-        supported_npad_id_types.resize(npad_id_list.size());
-        std::memcpy(supported_npad_id_types.data(), npad_id_list.data(),
-                    npad_id_list.size() * sizeof(u32));
-        AddNewController(PREFERRED_CONTROLLER);
-    }
-}
-
-void Controller_NPad::OnLoadInputDevices() {
-    std::transform(Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
-                   Settings::values.buttons.begin() + Settings::NativeButton::BUTTON_HID_END,
-                   buttons.begin(), Input::CreateDevice<Input::ButtonDevice>);
-    std::transform(Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
-                   Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_END,
-                   sticks.begin(), Input::CreateDevice<Input::AnalogDevice>);
-}
-
-void Controller_NPad::OnRelease() {}
-
-void Controller_NPad::OnUpdate(u8* data, std::size_t data_len) {
-    if (!IsControllerActivated())
-        return;
-    for (std::size_t i = 0; i < shared_memory_entries.size(); i++) {
-        auto& npad = shared_memory_entries[i];
-        const std::array<NPadGeneric*, 7> controller_npads{&npad.main_controller_states,
-                                                           &npad.handheld_states,
-                                                           &npad.dual_states,
-                                                           &npad.left_joy_states,
-                                                           &npad.right_joy_states,
-                                                           &npad.pokeball_states,
-                                                           &npad.libnx};
-
-        for (auto* main_controller : controller_npads) {
-            main_controller->common.entry_count = 16;
-            main_controller->common.total_entry_count = 17;
-
-            const auto& last_entry =
-                main_controller->npad[main_controller->common.last_entry_index];
-
-            main_controller->common.timestamp = CoreTiming::GetTicks();
-            main_controller->common.last_entry_index =
-                (main_controller->common.last_entry_index + 1) % 17;
-
-            auto& cur_entry = main_controller->npad[main_controller->common.last_entry_index];
-
-            cur_entry.timestamp = last_entry.timestamp + 1;
-            cur_entry.timestamp2 = cur_entry.timestamp;
-        }
-
-        const auto& controller_type = connected_controllers[i].type;
-
-        if (controller_type == NPadControllerType::None || !connected_controllers[i].is_connected) {
-            continue;
-        }
-
-        // Pad states
-        ControllerPadState pad_state{};
-        using namespace Settings::NativeButton;
-        pad_state.a.Assign(buttons[A - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.b.Assign(buttons[B - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.x.Assign(buttons[X - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.y.Assign(buttons[Y - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.l_stick.Assign(buttons[LStick - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.r_stick.Assign(buttons[RStick - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.l.Assign(buttons[L - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.r.Assign(buttons[R - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.zl.Assign(buttons[ZL - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.zr.Assign(buttons[ZR - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.plus.Assign(buttons[Plus - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.minus.Assign(buttons[Minus - BUTTON_HID_BEGIN]->GetStatus());
-
-        pad_state.d_left.Assign(buttons[DLeft - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.d_up.Assign(buttons[DUp - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.d_right.Assign(buttons[DRight - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.d_down.Assign(buttons[DDown - BUTTON_HID_BEGIN]->GetStatus());
-
-        pad_state.l_stick_left.Assign(buttons[LStick_Left - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.l_stick_up.Assign(buttons[LStick_Up - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.l_stick_right.Assign(buttons[LStick_Right - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.l_stick_down.Assign(buttons[LStick_Down - BUTTON_HID_BEGIN]->GetStatus());
-
-        pad_state.r_stick_left.Assign(buttons[RStick_Left - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.r_stick_up.Assign(buttons[RStick_Up - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.r_stick_right.Assign(buttons[RStick_Right - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.r_stick_down.Assign(buttons[RStick_Down - BUTTON_HID_BEGIN]->GetStatus());
-
-        pad_state.sl.Assign(buttons[SL - BUTTON_HID_BEGIN]->GetStatus());
-        pad_state.sr.Assign(buttons[SR - BUTTON_HID_BEGIN]->GetStatus());
-
-        AnalogPosition lstick_entry{};
-        AnalogPosition rstick_entry{};
-
-        const auto [stick_l_x_f, stick_l_y_f] =
-            sticks[static_cast<std::size_t>(JoystickId::Joystick_Left)]->GetStatus();
-        const auto [stick_r_x_f, stick_r_y_f] =
-            sticks[static_cast<std::size_t>(JoystickId::Joystick_Right)]->GetStatus();
-        lstick_entry.x = static_cast<s32>(stick_l_x_f * HID_JOYSTICK_MAX);
-        lstick_entry.y = static_cast<s32>(stick_l_y_f * HID_JOYSTICK_MAX);
-        rstick_entry.x = static_cast<s32>(stick_r_x_f * HID_JOYSTICK_MAX);
-        rstick_entry.y = static_cast<s32>(stick_r_y_f * HID_JOYSTICK_MAX);
-
-        if (controller_type == NPadControllerType::JoyLeft ||
-            controller_type == NPadControllerType::JoyRight) {
-            if (npad.properties.is_horizontal) {
-                ControllerPadState state{};
-                AnalogPosition temp_lstick_entry{};
-                AnalogPosition temp_rstick_entry{};
-                if (controller_type == NPadControllerType::JoyLeft) {
-                    state.d_down.Assign(pad_state.d_left.Value());
-                    state.d_left.Assign(pad_state.d_up.Value());
-                    state.d_right.Assign(pad_state.d_down.Value());
-                    state.d_up.Assign(pad_state.d_right.Value());
-                    state.l.Assign(pad_state.l.Value() | pad_state.sl.Value());
-                    state.r.Assign(pad_state.r.Value() | pad_state.sr.Value());
-
-                    state.zl.Assign(pad_state.zl.Value());
-                    state.plus.Assign(pad_state.minus.Value());
-
-                    temp_lstick_entry = lstick_entry;
-                    temp_rstick_entry = rstick_entry;
-                    std::swap(temp_lstick_entry.x, temp_lstick_entry.y);
-                    std::swap(temp_rstick_entry.x, temp_rstick_entry.y);
-                    temp_lstick_entry.y *= -1;
-                } else if (controller_type == NPadControllerType::JoyRight) {
-                    state.x.Assign(pad_state.a.Value());
-                    state.a.Assign(pad_state.b.Value());
-                    state.b.Assign(pad_state.y.Value());
-                    state.y.Assign(pad_state.b.Value());
-
-                    state.l.Assign(pad_state.l.Value() | pad_state.sl.Value());
-                    state.r.Assign(pad_state.r.Value() | pad_state.sr.Value());
-                    state.zr.Assign(pad_state.zr.Value());
-                    state.plus.Assign(pad_state.plus.Value());
-
-                    temp_lstick_entry = lstick_entry;
-                    temp_rstick_entry = rstick_entry;
-                    std::swap(temp_lstick_entry.x, temp_lstick_entry.y);
-                    std::swap(temp_rstick_entry.x, temp_rstick_entry.y);
-                    temp_rstick_entry.x *= -1;
-                }
-                pad_state.raw = state.raw;
-                lstick_entry = temp_lstick_entry;
-                rstick_entry = temp_rstick_entry;
-            }
-        }
-
-        auto& main_controller =
-            npad.main_controller_states.npad[npad.main_controller_states.common.last_entry_index];
-        auto& handheld_entry =
-            npad.handheld_states.npad[npad.handheld_states.common.last_entry_index];
-        auto& dual_entry = npad.dual_states.npad[npad.dual_states.common.last_entry_index];
-        auto& left_entry = npad.left_joy_states.npad[npad.left_joy_states.common.last_entry_index];
-        auto& right_entry =
-            npad.right_joy_states.npad[npad.right_joy_states.common.last_entry_index];
-        auto& pokeball_entry =
-            npad.pokeball_states.npad[npad.pokeball_states.common.last_entry_index];
-        auto& libnx_entry = npad.libnx.npad[npad.libnx.common.last_entry_index];
-
-        if (hold_type == NpadHoldType::Horizontal) {
-            // TODO(ogniK): Remap buttons for different orientations
-        }
-        libnx_entry.connection_status.raw = 0;
-
-        switch (controller_type) {
-        case NPadControllerType::Handheld:
-            handheld_entry.connection_status.raw = 0;
-            handheld_entry.connection_status.IsConnected.Assign(1);
-            if (!Settings::values.use_docked_mode) {
-                handheld_entry.connection_status.IsWired.Assign(1);
-            }
-            handheld_entry.pad_states.raw = pad_state.raw;
-            handheld_entry.l_stick = lstick_entry;
-            handheld_entry.r_stick = rstick_entry;
-            break;
-        case NPadControllerType::JoyDual:
-            dual_entry.connection_status.raw = 0;
-
-            dual_entry.connection_status.IsLeftJoyConnected.Assign(1);
-            dual_entry.connection_status.IsRightJoyConnected.Assign(1);
-            dual_entry.connection_status.IsConnected.Assign(1);
-
-            libnx_entry.connection_status.IsLeftJoyConnected.Assign(1);
-            libnx_entry.connection_status.IsRightJoyConnected.Assign(1);
-            libnx_entry.connection_status.IsConnected.Assign(1);
-
-            dual_entry.pad_states.raw = pad_state.raw;
-            dual_entry.l_stick = lstick_entry;
-            dual_entry.r_stick = rstick_entry;
-        case NPadControllerType::JoyLeft:
-            left_entry.connection_status.raw = 0;
-
-            left_entry.connection_status.IsConnected.Assign(1);
-            left_entry.pad_states.raw = pad_state.raw;
-            left_entry.l_stick = lstick_entry;
-            left_entry.r_stick = rstick_entry;
-            break;
-        case NPadControllerType::JoyRight:
-            right_entry.connection_status.raw = 0;
-
-            right_entry.connection_status.IsConnected.Assign(1);
-            right_entry.pad_states.raw = pad_state.raw;
-            right_entry.l_stick = lstick_entry;
-            right_entry.r_stick = rstick_entry;
-            break;
-        case NPadControllerType::Pokeball:
-            pokeball_entry.connection_status.raw = 0;
-
-            pokeball_entry.connection_status.IsConnected.Assign(1);
-            pokeball_entry.connection_status.IsWired.Assign(1);
-
-            pokeball_entry.pad_states.raw = pad_state.raw;
-            pokeball_entry.l_stick = lstick_entry;
-            pokeball_entry.r_stick = rstick_entry;
-            break;
-        case NPadControllerType::ProController:
-            main_controller.connection_status.raw = 0;
-
-            main_controller.connection_status.IsConnected.Assign(1);
-            main_controller.connection_status.IsWired.Assign(1);
-            main_controller.pad_states.raw = pad_state.raw;
-            main_controller.l_stick = lstick_entry;
-            main_controller.r_stick = rstick_entry;
-            break;
-        }
-
-        // LibNX exclusively uses this section, so we always update it since LibNX doesn't activate
-        // any controllers.
-        libnx_entry.pad_states.raw = pad_state.raw;
-        libnx_entry.l_stick = lstick_entry;
-        libnx_entry.r_stick = rstick_entry;
-    }
-    std::memcpy(data + NPAD_OFFSET, shared_memory_entries.data(),
-                shared_memory_entries.size() * sizeof(NPadEntry));
-} // namespace Service::HID
-
-void Controller_NPad::SetSupportedStyleSet(NPadType style_set) {
-    style.raw = style_set.raw;
-}
-
-Controller_NPad::NPadType Controller_NPad::GetSupportedStyleSet() const {
-    return style;
-}
-
-void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
-    ASSERT(length > 0 && (length % sizeof(u32)) == 0);
-    supported_npad_id_types.clear();
-    supported_npad_id_types.resize(length / sizeof(u32));
-    std::memcpy(supported_npad_id_types.data(), data, length);
-    for (std::size_t i = 0; i < connected_controllers.size(); i++) {
-        auto& controller = connected_controllers[i];
-        if (!controller.is_connected) {
-            continue;
-        }
-        if (!IsControllerSupported(PREFERRED_CONTROLLER)) {
-            controller.type = DecideBestController(PREFERRED_CONTROLLER);
-            InitNewlyAddedControler(i);
-        }
-    }
-}
-
-void Controller_NPad::GetSupportedNpadIdTypes(u32* data, std::size_t max_length) {
-    ASSERT(max_length < supported_npad_id_types.size());
-    std::memcpy(data, supported_npad_id_types.data(), supported_npad_id_types.size());
-}
-
-std::size_t Controller_NPad::GetSupportedNPadIdTypesSize() const {
-    return supported_npad_id_types.size();
-}
-
-void Controller_NPad::SetHoldType(NpadHoldType joy_hold_type) {
-    hold_type = joy_hold_type;
-}
-Controller_NPad::NpadHoldType Controller_NPad::GetHoldType() const {
-    return hold_type;
-}
-
-void Controller_NPad::SetNpadMode(u32 npad_id, NPadAssignments assignment_mode) {
-    ASSERT(npad_id < shared_memory_entries.size());
-    shared_memory_entries[npad_id].pad_assignment = assignment_mode;
-}
-
-void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
-                                        const std::vector<Vibration>& vibrations) {
-    if (!can_controllers_vibrate) {
-        return;
-    }
-    for (std::size_t i = 0; i < controller_ids.size(); i++) {
-        std::size_t controller_pos = i;
-        // Handheld controller conversion
-        if (controller_pos == NPAD_HANDHELD) {
-            controller_pos = 8;
-        }
-        // Unknown controller conversion
-        if (controller_pos == NPAD_UNKNOWN) {
-            controller_pos = 9;
-        }
-        if (connected_controllers[controller_pos].is_connected) {
-            // TODO(ogniK): Vibrate the physical controller
-        }
-    }
-    LOG_WARNING(Service_HID, "(STUBBED) called");
-    last_processed_vibration = vibrations.back();
-}
-
-Kernel::SharedPtr<Kernel::Event> Controller_NPad::GetStyleSetChangedEvent() const {
-    return styleset_changed_event;
-}
-
-Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {
-    return last_processed_vibration;
-}
-void Controller_NPad::AddNewController(NPadControllerType controller) {
-    if (controller == NPadControllerType::Handheld) {
-        connected_controllers[8] = {controller, true};
-        InitNewlyAddedControler(8);
-        return;
-    }
-    const auto pos =
-        std::find_if(connected_controllers.begin(), connected_controllers.end() - 2,
-                     [](const ControllerHolder& holder) { return !holder.is_connected; });
-    if (pos == connected_controllers.end() - 2) {
-        LOG_ERROR(Service_HID, "Cannot connect any more controllers!");
-        return;
-    }
-    const auto controller_id = std::distance(connected_controllers.begin(), pos);
-    connected_controllers[controller_id] = {controller, true};
-    InitNewlyAddedControler(controller_id);
-}
-
-void Controller_NPad::ConnectNPad(u32 npad_id) {
-    if (npad_id >= connected_controllers.size())
-        return;
-    connected_controllers[npad_id].is_connected = true;
-}
-
-void Controller_NPad::DisconnectNPad(u32 npad_id) {
-    if (npad_id >= connected_controllers.size())
-        return;
-    connected_controllers[npad_id].is_connected = false;
-}
-
-Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
-    if (npad_id == npad_id_list.back() || npad_id == npad_id_list[npad_id_list.size() - 2]) {
-        // These are controllers without led patterns
-        return LedPattern{0, 0, 0, 0};
-    }
-    switch (npad_id) {
-    case 0:
-        return LedPattern{1, 0, 0, 0};
-    case 1:
-        return LedPattern{0, 1, 0, 0};
-    case 2:
-        return LedPattern{0, 0, 1, 0};
-    case 3:
-        return LedPattern{0, 0, 0, 1};
-    case 4:
-        return LedPattern{1, 0, 0, 1};
-    case 5:
-        return LedPattern{1, 0, 1, 0};
-    case 6:
-        return LedPattern{1, 0, 1, 1};
-    case 7:
-        return LedPattern{0, 1, 1, 0};
-    default:
-        UNIMPLEMENTED_MSG("Unhandled npad_id {}", npad_id);
-        return LedPattern{0, 0, 0, 0};
-    };
-}
-void Controller_NPad::SetVibrationEnabled(bool can_vibrate) {
-    can_controllers_vibrate = can_vibrate;
-}
-
-bool Controller_NPad::IsControllerSupported(NPadControllerType controller) const {
-    const bool support_handheld =
-        std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(), NPAD_HANDHELD) !=
-        supported_npad_id_types.end();
-    if (controller == NPadControllerType::Handheld) {
-        // Handheld is not even a supported type, lets stop here
-        if (!support_handheld) {
-            return false;
-        }
-        // Handheld should not be supported in docked mode
-        if (Settings::values.use_docked_mode) {
-            return false;
-        }
-
-        return true;
-    }
-    if (std::any_of(supported_npad_id_types.begin(), supported_npad_id_types.end(),
-                    [](u32 npad_id) { return npad_id <= MAX_NPAD_ID; })) {
-        switch (controller) {
-        case NPadControllerType::ProController:
-            return style.pro_controller;
-        case NPadControllerType::JoyDual:
-            return style.joycon_dual;
-        case NPadControllerType::JoyLeft:
-            return style.joycon_left;
-        case NPadControllerType::JoyRight:
-            return style.joycon_right;
-        case NPadControllerType::Pokeball:
-            return style.pokeball;
-        default:
-            return false;
-        }
-    }
-    return false;
-}
-
-Controller_NPad::NPadControllerType Controller_NPad::DecideBestController(
-    NPadControllerType priority) const {
-    if (IsControllerSupported(priority)) {
-        return priority;
-    }
-    const auto is_docked = Settings::values.use_docked_mode;
-    if (is_docked && priority == NPadControllerType::Handheld) {
-        priority = NPadControllerType::JoyDual;
-        if (IsControllerSupported(priority)) {
-            return priority;
-        }
-    }
-    std::vector<NPadControllerType> priority_list;
-    switch (priority) {
-    case NPadControllerType::ProController:
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::Handheld:
-        priority_list.push_back(NPadControllerType::JoyDual);
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::JoyDual:
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::JoyLeft:
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::JoyRight:
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::Pokeball);
-        break;
-    case NPadControllerType::Pokeball:
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        break;
-    default:
-        priority_list.push_back(NPadControllerType::JoyDual);
-        if (!is_docked) {
-            priority_list.push_back(NPadControllerType::Handheld);
-        }
-        priority_list.push_back(NPadControllerType::ProController);
-        priority_list.push_back(NPadControllerType::JoyLeft);
-        priority_list.push_back(NPadControllerType::JoyRight);
-        priority_list.push_back(NPadControllerType::JoyDual);
-    }
-
-    const auto iter = std::find_if(priority_list.begin(), priority_list.end(),
-                                   [this](auto type) { return IsControllerSupported(type); });
-    if (iter == priority_list.end()) {
-        UNIMPLEMENTED_MSG("Could not find supported controller!");
-        return priority;
-    }
-
-    return *iter;
-}
-
-} // namespace Service::HID

src/core/hle/service/hid/controllers/npad.h

@@ -1,289 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include "common/common_types.h"
-#include "core/frontend/input.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
-#include "core/settings.h"
-
-namespace Service::HID {
-
-class Controller_NPad final : public ControllerBase {
-public:
-    Controller_NPad();
-    ~Controller_NPad() override;
-
-    // Called when the controller is initialized
-    void OnInit() override;
-
-    // When the controller is released
-    void OnRelease() override;
-
-    // When the controller is requesting an update for the shared memory
-    void OnUpdate(u8* data, std::size_t size) override;
-
-    // Called when input devices should be loaded
-    void OnLoadInputDevices() override;
-
-    struct NPadType {
-        union {
-            u32_le raw{};
-
-            BitField<0, 1, u32_le> pro_controller;
-            BitField<1, 1, u32_le> handheld;
-            BitField<2, 1, u32_le> joycon_dual;
-            BitField<3, 1, u32_le> joycon_left;
-            BitField<4, 1, u32_le> joycon_right;
-
-            BitField<6, 1, u32_le> pokeball; // TODO(ogniK): Confirm when possible
-        };
-    };
-    static_assert(sizeof(NPadType) == 4, "NPadType is an invalid size");
-
-    struct Vibration {
-        f32 amp_low;
-        f32 freq_low;
-        f32 amp_high;
-        f32 freq_high;
-    };
-    static_assert(sizeof(Vibration) == 0x10, "Vibration is an invalid size");
-
-    enum class NpadHoldType : u64 {
-        Vertical = 0,
-        Horizontal = 1,
-    };
-
-    enum class NPadAssignments : u32_le {
-        Dual = 0,
-        Single = 1,
-    };
-
-    enum class NPadControllerType {
-        None,
-        ProController,
-        Handheld,
-        JoyDual,
-        JoyLeft,
-        JoyRight,
-        Pokeball,
-    };
-
-    struct LedPattern {
-        explicit LedPattern(u64 light1, u64 light2, u64 light3, u64 light4) {
-            position1.Assign(light1);
-            position1.Assign(light2);
-            position1.Assign(light3);
-            position1.Assign(light4);
-        }
-        union {
-            u64 raw{};
-            BitField<0, 1, u64> position1;
-            BitField<1, 1, u64> position2;
-            BitField<2, 1, u64> position3;
-            BitField<3, 1, u64> position4;
-        };
-    };
-
-    void SetSupportedStyleSet(NPadType style_set);
-    NPadType GetSupportedStyleSet() const;
-
-    void SetSupportedNPadIdTypes(u8* data, std::size_t length);
-    void GetSupportedNpadIdTypes(u32* data, std::size_t max_length);
-    std::size_t GetSupportedNPadIdTypesSize() const;
-
-    void SetHoldType(NpadHoldType joy_hold_type);
-    NpadHoldType GetHoldType() const;
-
-    void SetNpadMode(u32 npad_id, NPadAssignments assignment_mode);
-
-    void VibrateController(const std::vector<u32>& controller_ids,
-                           const std::vector<Vibration>& vibrations);
-
-    Kernel::SharedPtr<Kernel::Event> GetStyleSetChangedEvent() const;
-    Vibration GetLastVibration() const;
-
-    void AddNewController(NPadControllerType controller);
-
-    void ConnectNPad(u32 npad_id);
-    void DisconnectNPad(u32 npad_id);
-    LedPattern GetLedPattern(u32 npad_id);
-    void SetVibrationEnabled(bool can_vibrate);
-
-private:
-    struct CommonHeader {
-        s64_le timestamp;
-        s64_le total_entry_count;
-        s64_le last_entry_index;
-        s64_le entry_count;
-    };
-    static_assert(sizeof(CommonHeader) == 0x20, "CommonHeader is an invalid size");
-
-    struct ControllerColor {
-        u32_le body_color;
-        u32_le button_color;
-    };
-    static_assert(sizeof(ControllerColor) == 8, "ControllerColor is an invalid size");
-
-    struct ControllerPadState {
-        union {
-            u64_le raw{};
-            // Button states
-            BitField<0, 1, u64_le> a;
-            BitField<1, 1, u64_le> b;
-            BitField<2, 1, u64_le> x;
-            BitField<3, 1, u64_le> y;
-            BitField<4, 1, u64_le> l_stick;
-            BitField<5, 1, u64_le> r_stick;
-            BitField<6, 1, u64_le> l;
-            BitField<7, 1, u64_le> r;
-            BitField<8, 1, u64_le> zl;
-            BitField<9, 1, u64_le> zr;
-            BitField<10, 1, u64_le> plus;
-            BitField<11, 1, u64_le> minus;
-
-            // D-Pad
-            BitField<12, 1, u64_le> d_left;
-            BitField<13, 1, u64_le> d_up;
-            BitField<14, 1, u64_le> d_right;
-            BitField<15, 1, u64_le> d_down;
-
-            // Left JoyStick
-            BitField<16, 1, u64_le> l_stick_left;
-            BitField<17, 1, u64_le> l_stick_up;
-            BitField<18, 1, u64_le> l_stick_right;
-            BitField<19, 1, u64_le> l_stick_down;
-
-            // Right JoyStick
-            BitField<20, 1, u64_le> r_stick_left;
-            BitField<21, 1, u64_le> r_stick_up;
-            BitField<22, 1, u64_le> r_stick_right;
-            BitField<23, 1, u64_le> r_stick_down;
-
-            // Not always active?
-            BitField<24, 1, u64_le> sl;
-            BitField<25, 1, u64_le> sr;
-        };
-    };
-    static_assert(sizeof(ControllerPadState) == 8, "ControllerPadState is an invalid size");
-
-    struct AnalogPosition {
-        s32_le x;
-        s32_le y;
-    };
-    static_assert(sizeof(AnalogPosition) == 8, "AnalogPosition is an invalid size");
-
-    struct ConnectionState {
-        union {
-            u32_le raw{};
-            BitField<0, 1, u32_le> IsConnected;
-            BitField<1, 1, u32_le> IsWired;
-            BitField<2, 1, u32_le> IsLeftJoyConnected;
-            BitField<3, 1, u32_le> IsLeftJoyWired;
-            BitField<4, 1, u32_le> IsRightJoyConnected;
-            BitField<5, 1, u32_le> IsRightJoyWired;
-        };
-    };
-    static_assert(sizeof(ConnectionState) == 4, "ConnectionState is an invalid size");
-
-    struct GenericStates {
-        s64_le timestamp;
-        s64_le timestamp2;
-        ControllerPadState pad_states;
-        AnalogPosition l_stick;
-        AnalogPosition r_stick;
-        ConnectionState connection_status;
-    };
-    static_assert(sizeof(GenericStates) == 0x30, "NPadGenericStates is an invalid size");
-
-    struct NPadGeneric {
-        CommonHeader common;
-        std::array<GenericStates, 17> npad;
-    };
-    static_assert(sizeof(NPadGeneric) == 0x350, "NPadGeneric is an invalid size");
-
-    enum class ColorReadError : u32_le {
-        ReadOk = 0,
-        ColorDoesntExist = 1,
-        NoController = 2,
-    };
-
-    struct NPadProperties {
-        union {
-            s64_le raw{};
-            BitField<11, 1, s64_le> is_vertical;
-            BitField<12, 1, s64_le> is_horizontal;
-            BitField<13, 1, s64_le> use_plus;
-            BitField<14, 1, s64_le> use_minus;
-        };
-    };
-
-    struct NPadDevice {
-        union {
-            u32_le raw{};
-            BitField<0, 1, s32_le> pro_controller;
-            BitField<1, 1, s32_le> handheld;
-            BitField<2, 1, s32_le> handheld_left;
-            BitField<3, 1, s32_le> handheld_right;
-            BitField<4, 1, s32_le> joycon_left;
-            BitField<5, 1, s32_le> joycon_right;
-            BitField<6, 1, s32_le> pokeball;
-        };
-    };
-
-    struct NPadEntry {
-        NPadType joy_styles;
-        NPadAssignments pad_assignment;
-
-        ColorReadError single_color_error;
-        ControllerColor single_color;
-
-        ColorReadError dual_color_error;
-        ControllerColor left_color;
-        ControllerColor right_color;
-
-        NPadGeneric main_controller_states;
-        NPadGeneric handheld_states;
-        NPadGeneric dual_states;
-        NPadGeneric left_joy_states;
-        NPadGeneric right_joy_states;
-        NPadGeneric pokeball_states;
-        NPadGeneric libnx; // TODO(ogniK): Find out what this actually is, libnx seems to only be
-                           // relying on this for the time being
-        INSERT_PADDING_BYTES(
-            0x708 *
-            6); // TODO(ogniK): SixAxis states, require more information before implementation
-        NPadDevice device_type;
-        NPadProperties properties;
-        INSERT_PADDING_WORDS(1);
-        std::array<u32, 3> battery_level;
-        INSERT_PADDING_BYTES(0x5c);
-        INSERT_PADDING_BYTES(0xdf8);
-    };
-    static_assert(sizeof(NPadEntry) == 0x5000, "NPadEntry is an invalid size");
-
-    struct ControllerHolder {
-        Controller_NPad::NPadControllerType type;
-        bool is_connected;
-    };
-
-    NPadType style{};
-    std::array<NPadEntry, 10> shared_memory_entries{};
-    std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeButton::NUM_BUTTONS_HID>
-        buttons;
-    std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID> sticks;
-    std::vector<u32> supported_npad_id_types{};
-    NpadHoldType hold_type{NpadHoldType::Vertical};
-    Kernel::SharedPtr<Kernel::Event> styleset_changed_event;
-    Vibration last_processed_vibration{};
-    std::array<ControllerHolder, 10> connected_controllers{};
-    bool can_controllers_vibrate{true};
-
-    void InitNewlyAddedControler(std::size_t controller_idx);
-    bool IsControllerSupported(NPadControllerType controller) const;
-    NPadControllerType DecideBestController(NPadControllerType priority) const;
-};
-} // namespace Service::HID

src/core/hle/service/hid/controllers/stubbed.cpp

@@ -1,39 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/common_types.h"
-#include "core/core_timing.h"
-#include "core/hle/service/hid/controllers/stubbed.h"
-
-namespace Service::HID {
-
-Controller_Stubbed::Controller_Stubbed() = default;
-Controller_Stubbed::~Controller_Stubbed() = default;
-
-void Controller_Stubbed::OnInit() {}
-
-void Controller_Stubbed::OnRelease() {}
-
-void Controller_Stubbed::OnUpdate(u8* data, std::size_t size) {
-    if (!smart_update) {
-        return;
-    }
-
-    CommonHeader header{};
-    header.timestamp = CoreTiming::GetTicks();
-    header.total_entry_count = 17;
-    header.entry_count = 0;
-    header.last_entry_index = 0;
-
-    std::memcpy(data + common_offset, &header, sizeof(CommonHeader));
-}
-
-void Controller_Stubbed::OnLoadInputDevices() {}
-
-void Controller_Stubbed::SetCommonHeaderOffset(std::size_t off) {
-    common_offset = off;
-    smart_update = true;
-}
-} // namespace Service::HID

src/core/hle/service/hid/controllers/stubbed.h

@@ -1,34 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "core/hle/service/hid/controllers/controller_base.h"
-
-namespace Service::HID {
-class Controller_Stubbed final : public ControllerBase {
-public:
-    Controller_Stubbed();
-    ~Controller_Stubbed() override;
-
-    // Called when the controller is initialized
-    void OnInit() override;
-
-    // When the controller is released
-    void OnRelease() override;
-
-    // When the controller is requesting an update for the shared memory
-    void OnUpdate(u8* data, std::size_t size) override;
-
-    // Called when input devices should be loaded
-    void OnLoadInputDevices() override;
-
-    void SetCommonHeaderOffset(std::size_t off);
-
-private:
-    bool smart_update{};
-    std::size_t common_offset{};
-};
-} // namespace Service::HID

src/core/hle/service/hid/controllers/touchscreen.cpp

@@ -1,65 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "common/common_types.h"
-#include "core/core_timing.h"
-#include "core/frontend/emu_window.h"
-#include "core/frontend/input.h"
-#include "core/hle/service/hid/controllers/touchscreen.h"
-#include "core/settings.h"
-
-namespace Service::HID {
-constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;
-
-Controller_Touchscreen::Controller_Touchscreen() = default;
-Controller_Touchscreen::~Controller_Touchscreen() = default;
-
-void Controller_Touchscreen::OnInit() {}
-
-void Controller_Touchscreen::OnRelease() {}
-
-void Controller_Touchscreen::OnUpdate(u8* data, std::size_t size) {
-    shared_memory.header.timestamp = CoreTiming::GetTicks();
-    shared_memory.header.total_entry_count = 17;
-
-    if (!IsControllerActivated()) {
-        shared_memory.header.entry_count = 0;
-        shared_memory.header.last_entry_index = 0;
-        return;
-    }
-    shared_memory.header.entry_count = 16;
-
-    const auto& last_entry =
-        shared_memory.shared_memory_entries[shared_memory.header.last_entry_index];
-    shared_memory.header.last_entry_index = (shared_memory.header.last_entry_index + 1) % 17;
-    auto& cur_entry = shared_memory.shared_memory_entries[shared_memory.header.last_entry_index];
-
-    cur_entry.sampling_number = last_entry.sampling_number + 1;
-    cur_entry.sampling_number2 = cur_entry.sampling_number;
-
-    const auto [x, y, pressed] = touch_device->GetStatus();
-    auto& touch_entry = cur_entry.states[0];
-    if (pressed) {
-        touch_entry.x = static_cast<u16>(x * Layout::ScreenUndocked::Width);
-        touch_entry.y = static_cast<u16>(y * Layout::ScreenUndocked::Height);
-        touch_entry.diameter_x = 15;
-        touch_entry.diameter_y = 15;
-        touch_entry.rotation_angle = 0;
-        const u64 tick = CoreTiming::GetTicks();
-        touch_entry.delta_time = tick - last_touch;
-        last_touch = tick;
-        touch_entry.finger = 0;
-        cur_entry.entry_count = 1;
-    } else {
-        cur_entry.entry_count = 0;
-    }
-
-    std::memcpy(data + SHARED_MEMORY_OFFSET, &shared_memory, sizeof(TouchScreenSharedMemory));
-}
-
-void Controller_Touchscreen::OnLoadInputDevices() {
-    touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values.touch_device);
-}
-} // namespace Service::HID