Services/LDR: Implemented the ldr:ro LoadNRO andLoadNRR service functions.

The implementation was based on Atmosphere's implementation of the ldr:ro service. This is an incomplete commit, the error condition checks are missing.
Kernel/Memory: Added a function to first a suitable guest address at which to allocate a region of a given size.
2018-10-10 19:10:04 -05:00 · 2018-10-10 19:10:03 -05:00 · 2018-10-10 19:10:02 -05:00
265 changed files with 4721 additions and 12303 deletions
@@ -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
@@ -23,21 +23,21 @@ option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)

 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)

-if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
+if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit)
    message(STATUS "Copying pre-commit hook")
    file(COPY hooks/pre-commit
-        DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
+        DESTINATION ${CMAKE_SOURCE_DIR}/.git/hooks)
 endif()

 # Sanity check : Check that all submodules are present
 # =======================================================================

 function(check_submodules_present)
-    file(READ "${PROJECT_SOURCE_DIR}/.gitmodules" gitmodules)
+    file(READ "${CMAKE_SOURCE_DIR}/.gitmodules" gitmodules)
    string(REGEX MATCHALL "path *= *[^ \t\r\n]*" gitmodules ${gitmodules})
    foreach(module ${gitmodules})
        string(REGEX REPLACE "path *= *" "" module ${module})
-        if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
+        if (NOT EXISTS "${CMAKE_SOURCE_DIR}/${module}/.git")
            message(FATAL_ERROR "Git submodule ${module} not found. "
                    "Please run: git submodule update --init --recursive")
        endif()
@@ -45,17 +45,17 @@ function(check_submodules_present)
 endfunction()
 check_submodules_present()

-configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
-               ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
+configure_file(${CMAKE_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
+               ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
               COPYONLY)
-if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
    message(STATUS "Downloading compatibility list for yuzu...")
    file(DOWNLOAD
        https://api.yuzu-emu.org/gamedb/
-        "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
+        "${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
 endif()
-if (NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    file(WRITE ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
+if (NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+    file(WRITE ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
 endif()

 # Detect current compilation architecture and create standard definitions
@@ -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()

@@ -178,6 +178,10 @@ endif()
 set_property(DIRECTORY APPEND PROPERTY
    COMPILE_DEFINITIONS $<$<CONFIG:Debug>:_DEBUG> $<$<NOT:$<CONFIG:Debug>>:NDEBUG>)

+
+math(EXPR EMU_ARCH_BITS ${CMAKE_SIZEOF_VOID_P}*8)
+add_definitions(-DEMU_ARCH_BITS=${EMU_ARCH_BITS})
+
 # System imported libraries
 # ======================

@@ -185,13 +189,13 @@ find_package(Boost 1.63.0 QUIET)
 if (NOT Boost_FOUND)
    message(STATUS "Boost 1.63.0 or newer not found, falling back to externals")

-    set(BOOST_ROOT "${PROJECT_SOURCE_DIR}/externals/boost")
+    set(BOOST_ROOT "${CMAKE_SOURCE_DIR}/externals/boost")
    set(Boost_NO_SYSTEM_PATHS OFF)
    find_package(Boost QUIET REQUIRED)
 endif()

 # Output binaries to bin/
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
@@ -260,7 +264,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
        endif()

        set(UNICORN_FOUND YES)
-        set(UNICORN_PREFIX ${PROJECT_SOURCE_DIR}/externals/unicorn)
+        set(UNICORN_PREFIX ${CMAKE_SOURCE_DIR}/externals/unicorn)
        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/${UNICORN_LIB_NAME}" CACHE PATH "Path to Unicorn library" FORCE)
        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/" CACHE PATH "Path to unicorn dynamic library" FORCE)
@@ -352,12 +356,12 @@ set(CLANG_FORMAT_POSTFIX "-6.0")
 find_program(CLANG_FORMAT
    NAMES clang-format${CLANG_FORMAT_POSTFIX}
          clang-format
-    PATHS ${PROJECT_BINARY_DIR}/externals)
+    PATHS ${CMAKE_BINARY_DIR}/externals)
 # if find_program doesn't find it, try to download from externals
 if (NOT CLANG_FORMAT)
    if (WIN32)
        message(STATUS "Clang format not found! Downloading...")
-        set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
+        set(CLANG_FORMAT "${CMAKE_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
        file(DOWNLOAD
            https://github.com/yuzu-emu/ext-windows-bin/raw/master/clang-format${CLANG_FORMAT_POSTFIX}.exe
            "${CLANG_FORMAT}" SHOW_PROGRESS
@@ -373,7 +377,7 @@ if (NOT CLANG_FORMAT)
 endif()

 if (CLANG_FORMAT)
-    set(SRCS ${PROJECT_SOURCE_DIR}/src)
+    set(SRCS ${CMAKE_SOURCE_DIR}/src)
    set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
    if (WIN32)
        add_custom_target(clang-format
@@ -446,10 +450,10 @@ endif()
 # http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
 # http://standards.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html
 if(ENABLE_QT AND UNIX AND NOT APPLE)
-    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.desktop"
+    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.desktop"
            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/applications")
-    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.svg"
+    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.svg"
            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/scalable/apps")
-    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.xml"
+    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.xml"
            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/mime/packages")
 endif()
@@ -121,8 +121,7 @@ CubebSink::CubebSink(std::string target_device_name) {
            const auto collection_end{collection.device + collection.count};
            const auto device{
                std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
-                    return info.friendly_name != nullptr &&
-                           target_device_name == info.friendly_name;
+                    return target_device_name == info.friendly_name;
                })};
            if (device != collection_end) {
                output_device = device->devid;
@@ -11,6 +11,7 @@
 #include "audio_core/stream.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "common/microprofile.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/settings.h"
@@ -103,7 +104,10 @@ void Stream::PlayNextBuffer() {
    CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }

+MICROPROFILE_DEFINE(AudioOutput, "Audio", "ReleaseActiveBuffer", MP_RGB(100, 100, 255));
+
 void Stream::ReleaseActiveBuffer() {
+    MICROPROFILE_SCOPE(AudioOutput);
    ASSERT(active_buffer);
    released_buffers.push(std::move(active_buffer));
    release_callback();
@@ -10,7 +10,8 @@

 namespace AudioCore {

-TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count) : m_sample_rate{sample_rate} {
+TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count)
+    : m_sample_rate(sample_rate), m_channel_count(channel_count) {
    m_sound_touch.setChannels(channel_count);
    m_sound_touch.setSampleRate(sample_rate);
    m_sound_touch.setPitch(1.0);
@@ -32,10 +33,10 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
    // We were given actual_samples number of samples, and num_samples were requested from us.
    double current_ratio = static_cast<double>(num_in) / static_cast<double>(num_out);

-    const double max_latency = 0.25; // seconds
+    const double max_latency = 1.0; // seconds
    const double max_backlog = m_sample_rate * max_latency;
    const double backlog_fullness = m_sound_touch.numSamples() / max_backlog;
-    if (backlog_fullness > 4.0) {
+    if (backlog_fullness > 5.0) {
        // Too many samples in backlog: Don't push anymore on
        num_in = 0;
    }
@@ -49,7 +50,7 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,

    // This low-pass filter smoothes out variance in the calculated stretch ratio.
    // The time-scale determines how responsive this filter is.
-    constexpr double lpf_time_scale = 0.712; // seconds
+    constexpr double lpf_time_scale = 2.0; // seconds
    const double lpf_gain = 1.0 - std::exp(-time_delta / lpf_time_scale);
    m_stretch_ratio += lpf_gain * (current_ratio - m_stretch_ratio);

@@ -27,6 +27,7 @@ public:

 private:
    u32 m_sample_rate;
+    u32 m_channel_count;
    soundtouch::SoundTouch m_sound_touch;
    double m_stretch_ratio = 1.0;
 };
@@ -64,6 +64,8 @@ add_library(common STATIC
    logging/text_formatter.cpp
    logging/text_formatter.h
    math_util.h
+    memory_util.cpp
+    memory_util.h
    microprofile.cpp
    microprofile.h
    microprofileui.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
@@ -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>
@@ -12,8 +12,7 @@
 #include <thread>
 #include <vector>
 #ifdef _WIN32
-#include <share.h>   // For _SH_DENYWR
-#include <windows.h> // For OutputDebugStringA
+#include <share.h> // For _SH_DENYWR
 #else
 #define _SH_DENYWR 0
 #endif
@@ -140,18 +139,12 @@ void FileBackend::Write(const Entry& entry) {
    if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
        return;
    }
-    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
+    bytes_written += file.WriteString(FormatLogMessage(entry) + '\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)                                                                                       \
@@ -203,7 +196,6 @@ void DebuggerBackend::Write(const Entry& entry) {
    SUB(Service, NFP)                                                                              \
    SUB(Service, NIFM)                                                                             \
    SUB(Service, NIM)                                                                              \
-    SUB(Service, NPNS)                                                                             \
    SUB(Service, NS)                                                                               \
    SUB(Service, NVDRV)                                                                            \
    SUB(Service, PCIE)                                                                             \
@@ -212,12 +204,10 @@ void DebuggerBackend::Write(const Entry& entry) {
    SUB(Service, PM)                                                                               \
    SUB(Service, PREPO)                                                                            \
    SUB(Service, PSC)                                                                              \
-    SUB(Service, PSM)                                                                              \
    SUB(Service, SET)                                                                              \
    SUB(Service, SM)                                                                               \
    SUB(Service, SPL)                                                                              \
    SUB(Service, SSL)                                                                              \
-    SUB(Service, TCAP)                                                                             \
    SUB(Service, Time)                                                                             \
    SUB(Service, USB)                                                                              \
    SUB(Service, VI)                                                                               \
@@ -103,20 +103,6 @@ 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);
@@ -83,7 +83,6 @@ enum class Class : ClassType {
    Service_NFP,       ///< The NFP service
    Service_NIFM,      ///< The NIFM (Network interface) service
    Service_NIM,       ///< The NIM service
-    Service_NPNS,      ///< The NPNS service
    Service_NS,        ///< The NS services
    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
    Service_PCIE,      ///< The PCIe service
@@ -92,12 +91,10 @@ 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
    Service_SSL,       ///< The SSL service
-    Service_TCAP,      ///< The TCAP service.
    Service_Time,      ///< The time service
    Service_USB,       ///< The USB (Universal Serial Bus) service
    Service_VI,        ///< The VI (Video interface) service
@@ -0,0 +1,177 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "common/memory_util.h"
+
+#ifdef _WIN32
+#include <windows.h>
+// Windows.h needs to be included before psapi.h
+#include <psapi.h>
+#include "common/common_funcs.h"
+#include "common/string_util.h"
+#else
+#include <cstdlib>
+#include <sys/mman.h>
+#endif
+
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+#include <unistd.h>
+#define PAGE_MASK (getpagesize() - 1)
+#define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
+#endif
+
+// This is purposely not a full wrapper for virtualalloc/mmap, but it
+// provides exactly the primitive operations that Dolphin needs.
+
+void* AllocateExecutableMemory(std::size_t size, bool low) {
+#if defined(_WIN32)
+    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+#else
+    static char* map_hint = nullptr;
+#if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+    // This OS has no flag to enforce allocation below the 4 GB boundary,
+    // but if we hint that we want a low address it is very likely we will
+    // get one.
+    // An older version of this code used MAP_FIXED, but that has the side
+    // effect of discarding already mapped pages that happen to be in the
+    // requested virtual memory range (such as the emulated RAM, sometimes).
+    if (low && (!map_hint))
+        map_hint = (char*)round_page(512 * 1024 * 1024); /* 0.5 GB rounded up to the next page */
+#endif
+    void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
+                     MAP_ANON | MAP_PRIVATE
+#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
+                         | (low ? MAP_32BIT : 0)
+#endif
+                         ,
+                     -1, 0);
+#endif /* defined(_WIN32) */
+
+#ifdef _WIN32
+    if (ptr == nullptr) {
+#else
+    if (ptr == MAP_FAILED) {
+        ptr = nullptr;
+#endif
+        LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
+    }
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+    else {
+        if (low) {
+            map_hint += size;
+            map_hint = (char*)round_page(map_hint); /* round up to the next page */
+        }
+    }
+#endif
+
+#if EMU_ARCH_BITS == 64
+    if ((u64)ptr >= 0x80000000 && low == true)
+        LOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!");
+#endif
+
+    return ptr;
+}
+
+void* AllocateMemoryPages(std::size_t size) {
+#ifdef _WIN32
+    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
+#else
+    void* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+
+    if (ptr == MAP_FAILED)
+        ptr = nullptr;
+#endif
+
+    if (ptr == nullptr)
+        LOG_ERROR(Common_Memory, "Failed to allocate raw memory");
+
+    return ptr;
+}
+
+void* AllocateAlignedMemory(std::size_t size, std::size_t alignment) {
+#ifdef _WIN32
+    void* ptr = _aligned_malloc(size, alignment);
+#else
+    void* ptr = nullptr;
+#ifdef ANDROID
+    ptr = memalign(alignment, size);
+#else
+    if (posix_memalign(&ptr, alignment, size) != 0)
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+#endif
+#endif
+
+    if (ptr == nullptr)
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+
+    return ptr;
+}
+
+void FreeMemoryPages(void* ptr, std::size_t size) {
+    if (ptr) {
+#ifdef _WIN32
+        if (!VirtualFree(ptr, 0, MEM_RELEASE))
+            LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
+#else
+        munmap(ptr, size);
+#endif
+    }
+}
+
+void FreeAlignedMemory(void* ptr) {
+    if (ptr) {
+#ifdef _WIN32
+        _aligned_free(ptr);
+#else
+        free(ptr);
+#endif
+    }
+}
+
+void WriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
+#ifdef _WIN32
+    DWORD oldValue;
+    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
+        LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
+#else
+    mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
+#endif
+}
+
+void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
+#ifdef _WIN32
+    DWORD oldValue;
+    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,
+                        &oldValue))
+        LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
+#else
+    mprotect(ptr, size,
+             allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);
+#endif
+}
+
+std::string MemUsage() {
+#ifdef _WIN32
+#pragma comment(lib, "psapi")
+    DWORD processID = GetCurrentProcessId();
+    HANDLE hProcess;
+    PROCESS_MEMORY_COUNTERS pmc;
+    std::string Ret;
+
+    // Print information about the memory usage of the process.
+
+    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);
+    if (nullptr == hProcess)
+        return "MemUsage Error";
+
+    if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
+        Ret = fmt::format("{} K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7));
+
+    CloseHandle(hProcess);
+    return Ret;
+#else
+    return "";
+#endif
+}
@@ -0,0 +1,21 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstddef>
+#include <string>
+
+void* AllocateExecutableMemory(std::size_t size, bool low = true);
+void* AllocateMemoryPages(std::size_t size);
+void FreeMemoryPages(void* ptr, std::size_t size);
+void* AllocateAlignedMemory(std::size_t size, std::size_t alignment);
+void FreeAlignedMemory(void* ptr);
+void WriteProtectMemory(void* ptr, std::size_t size, bool executable = false);
+void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute = false);
+std::string MemUsage();
+
+inline int GetPageSize() {
+    return 4096;
+}
@@ -153,7 +153,6 @@ struct VisitorInterface : NonCopyable {

    /// Completion method, called once all fields have been visited
    virtual void Complete() = 0;
-    virtual bool SubmitTestcase() = 0;
 };

 /**
@@ -179,9 +178,6 @@ struct NullVisitor : public VisitorInterface {
    void Visit(const Field<std::chrono::microseconds>& /*field*/) override {}

    void Complete() override {}
-    bool SubmitTestcase() override {
-        return false;
-    }
 };

 /// Appends build-specific information to the given FieldCollection,
@@ -5,7 +5,6 @@
 #pragma once

 #include <string>
-#include "common/common_types.h"

 namespace Common {
 struct WebResult {
@@ -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)
@@ -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();
@@ -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;
 };
@@ -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();
@@ -139,16 +139,16 @@ struct System::Impl {
        auto main_process = Kernel::Process::Create(kernel, "main");
        kernel.MakeCurrentProcess(main_process.get());

-        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 +160,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];
            }
        }

@@ -185,7 +185,7 @@ struct System::Impl {
            LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
            return ResultStatus::ErrorGetLoader;
        }
-        std::pair<std::optional<u32>, Loader::ResultStatus> system_mode =
+        std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
            app_loader->LoadKernelSystemMode();

        if (system_mode.second != Loader::ResultStatus::Success) {
@@ -245,7 +245,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 +282,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 +298,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;
@@ -312,10 +311,6 @@ Cpu& System::CurrentCpuCore() {
    return impl->CurrentCpuCore();
 }

-const Cpu& System::CurrentCpuCore() const {
-    return impl->CurrentCpuCore();
-}
-
 System::ResultStatus System::RunLoop(bool tight_loop) {
    return impl->RunLoop(tight_loop);
 }
@@ -346,11 +341,7 @@ PerfStatsResults System::GetAndResetPerfStats() {
    return impl->GetAndResetPerfStats();
 }

-TelemetrySession& System::TelemetrySession() {
-    return *impl->telemetry_session;
-}
-
-const TelemetrySession& System::TelemetrySession() const {
+Core::TelemetrySession& System::TelemetrySession() const {
    return *impl->telemetry_session;
 }

@@ -358,28 +349,17 @@ ARM_Interface& System::CurrentArmInterface() {
    return CurrentCpuCore().ArmInterface();
 }

-const ARM_Interface& System::CurrentArmInterface() const {
-    return CurrentCpuCore().ArmInterface();
-}
-
-std::size_t System::CurrentCoreIndex() const {
+std::size_t System::CurrentCoreIndex() {
    return CurrentCpuCore().CoreIndex();
 }

 Kernel::Scheduler& System::CurrentScheduler() {
-    return CurrentCpuCore().Scheduler();
+    return *CurrentCpuCore().Scheduler();
 }

-const Kernel::Scheduler& System::CurrentScheduler() const {
-    return CurrentCpuCore().Scheduler();
-}
-
-Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
-    return CpuCore(core_index).Scheduler();
-}
-
-const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
-    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();
 }

 Kernel::Process* System::CurrentProcess() {
@@ -391,11 +371,8 @@ const Kernel::Process* System::CurrentProcess() const {
 }

 ARM_Interface& System::ArmInterface(std::size_t core_index) {
-    return CpuCore(core_index).ArmInterface();
-}
-
-const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
-    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) {
@@ -403,19 +380,10 @@ 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;
 }

-const ExclusiveMonitor& System::Monitor() const {
-    return *impl->cpu_exclusive_monitor;
-}
-
 Tegra::GPU& System::GPU() {
    return *impl->gpu_core;
 }
@@ -129,11 +129,11 @@ public:
     */
    bool IsPoweredOn() const;

-    /// Gets a reference to the telemetry session for this emulation session.
-    Core::TelemetrySession& TelemetrySession();
-
-    /// Gets a reference to the telemetry session for this emulation session.
-    const Core::TelemetrySession& TelemetrySession() const;
+    /**
+     * Returns a reference to the telemetry session for this emulation session.
+     * @returns Reference to the telemetry session.
+     */
+    Core::TelemetrySession& TelemetrySession() const;

    /// Prepare the core emulation for a reschedule
    void PrepareReschedule();
@@ -144,36 +144,21 @@ public:
    /// Gets an ARM interface to the CPU core that is currently running
    ARM_Interface& CurrentArmInterface();

-    /// Gets an ARM interface to the CPU core that is currently running
-    const ARM_Interface& CurrentArmInterface() const;
-
    /// Gets the index of the currently running CPU core
-    std::size_t CurrentCoreIndex() const;
+    std::size_t CurrentCoreIndex();

    /// Gets the scheduler for the CPU core that is currently running
    Kernel::Scheduler& CurrentScheduler();

-    /// Gets the scheduler for the CPU core that is currently running
-    const Kernel::Scheduler& CurrentScheduler() const;
-
-    /// Gets a reference to an ARM interface for the CPU core with the specified index
+    /// Gets an ARM interface to the CPU core with the specified index
    ARM_Interface& ArmInterface(std::size_t core_index);

-    /// Gets a const reference to an ARM interface from the CPU core with the specified index
-    const ARM_Interface& ArmInterface(std::size_t core_index) const;
-
    /// 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 a reference to the exclusive monitor
+    /// Gets the exclusive monitor
    ExclusiveMonitor& Monitor();

-    /// Gets a constant reference to the exclusive monitor
-    const ExclusiveMonitor& Monitor() const;
-
    /// Gets a mutable reference to the GPU interface
    Tegra::GPU& GPU();

@@ -187,10 +172,7 @@ 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);
-
-    /// Gets the scheduler for the CPU core with the specified index
-    const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
+    const std::shared_ptr<Kernel::Scheduler>& Scheduler(std::size_t core_index);

    /// Provides a pointer to the current process
    Kernel::Process* CurrentProcess();
@@ -242,9 +224,6 @@ private:
    /// Returns the currently running CPU core
    Cpu& CurrentCpuCore();

-    /// Returns the currently running CPU core
-    const Cpu& CurrentCpuCore() const;
-
    /**
     * Initialize the emulated system.
     * @param emu_window Reference to the host-system window used for video output and keyboard
@@ -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;
    }
@@ -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;
@@ -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;
-}
-
-std::optional<Key128> DeriveSDSeed() {
+boost::optional<Key128> DeriveSDSeed() {
    const FileUtil::IOFile save_43(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                                       "/system/save/8000000000000043",
                                   "rb+");
    if (!save_43.IsOpen())
-        return {};
-
+        return boost::none;
    const FileUtil::IOFile sd_private(
        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir) + "/Nintendo/Contents/private", "rb+");
    if (!sd_private.IsOpen())
-        return {};
+        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()) {
-        return {};
-    }
+    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 {};
-        }
-
+        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)) {
-        return {};
-    }
+    if (offset + 0x10 >= save_43.GetSize())
+        return boost::none;

    Key128 seed{};
-    if (save_43.ReadBytes(seed.data(), seed.size()) != seed.size()) {
-        return {};
-    }
+    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 std::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 {};
-        }
-    }
-
-    return offset;
-}
-
-std::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 {};
-    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 {};
-
-    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 {};
-
-    m_1 = m_1 ^ MGF1<0x20>(m_2);
-    m_2 = m_2 ^ MGF1<0xDF>(m_1);
-
-    const auto offset = FindTicketOffset(m_2);
-    if (!offset)
-        return {};
-    ASSERT(*offset > 0);
-
-    std::memcpy(key_temp.data(), m_2.data() + *offset, 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::isxdigit(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;
 }

@@ -661,391 +286,63 @@ void KeyManager::DeriveSDSeedLazy() {
        return;

    const auto res = DeriveSDSeed();
-    if (res)
-        SetKey(S128KeyType::SDSeed, *res);
-}
-
-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);
-
-    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)
-            continue;
-        const auto& [rid, key] = *pair;
-        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();
+    if (res != boost::none)
+        SetKey(S128KeyType::SDSeed, res.get());
 }

 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
@@ -5,19 +5,11 @@
 #pragma once

 #include <array>
-#include <map>
-#include <optional>
 #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;
@@ -30,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 {
@@ -66,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 {
@@ -83,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 {
@@ -103,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;
@@ -144,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);

@@ -155,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);
-
-std::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)
-std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
-                                                     const RSAKeyPair<2048>& eticket_extended_key);
+boost::optional<Key128> DeriveSDSeed();
+Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, const KeyManager& keys);

 } // namespace Core::Crypto
@@ -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
@@ -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
@@ -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 {
@@ -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
@@ -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 {
@@ -168,6 +166,10 @@ VirtualDir XCI::GetParentDirectory() const {
    return file->GetContainingDirectory();
 }

+bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
    if (partitions[static_cast<std::size_t>(part)] == nullptr) {
        return Loader::ResultStatus::ErrorXCIMissingPartition;
@@ -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;
@@ -94,6 +94,9 @@ public:

    VirtualDir GetParentDirectory() const override;

+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
    Loader::ResultStatus AddNCAFromPartition(XCIPartition part);

@@ -4,9 +4,10 @@

 #include <algorithm>
 #include <cstring>
-#include <optional>
 #include <utility>

+#include <boost/optional.hpp>
+
 #include "common/logging/log.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
@@ -96,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});
-
-        std::optional<Core::Crypto::Key128> key = {};
-        if (encrypted) {
-            if (has_rights_id) {
-                status = Loader::ResultStatus::Success;
-                key = GetTitlekey();
-                if (!key) {
-                    status = Loader::ResultStatus::ErrorMissingTitlekey;
-                    return false;
-                }
-            } else {
-                key = GetKeyAreaKey(NCASectionCryptoType::BKTR);
-                if (!key) {
-                    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 : 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)
@@ -387,11 +111,11 @@ u8 NCA::GetCryptoRevision() const {
    return master_key_id;
 }

-std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
+boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
    const auto master_key_id = GetCryptoRevision();

    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
-        return {};
+        return boost::none;

    std::vector<u8> key_area(header.key_area.begin(), header.key_area.end());
    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -409,31 +133,31 @@ std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type
                     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;
 }

-std::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
+boost::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
    const auto master_key_id = GetCryptoRevision();

    u128 rights_id{};
    memcpy(rights_id.data(), header.rights_id.data(), 16);
    if (rights_id == u128{}) {
        status = Loader::ResultStatus::ErrorInvalidRightsID;
-        return {};
+        return boost::none;
    }

    auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
    if (titlekey == Core::Crypto::Key128{}) {
        status = Loader::ResultStatus::ErrorMissingTitlekey;
-        return {};
+        return boost::none;
    }

    if (!keys.HasKey(Core::Crypto::S128KeyType::Titlekek, master_key_id)) {
        status = Loader::ResultStatus::ErrorMissingTitlekek;
-        return {};
+        return boost::none;
    }

    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -443,7 +167,7 @@ std::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;

@@ -457,25 +181,25 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
    case NCASectionCryptoType::BKTR:
        LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
        {
-            std::optional<Core::Crypto::Key128> key = {};
+            boost::optional<Core::Crypto::Key128> key = boost::none;
            if (has_rights_id) {
                status = Loader::ResultStatus::Success;
                key = GetTitlekey();
-                if (!key) {
+                if (key == boost::none) {
                    if (status == Loader::ResultStatus::Success)
                        status = Loader::ResultStatus::ErrorMissingTitlekey;
                    return nullptr;
                }
            } else {
                key = GetKeyAreaKey(NCASectionCryptoType::CTR);
-                if (!key) {
+                if (key == boost::none) {
                    status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
                    return nullptr;
                }
            }

-            auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(std::move(in), *key,
-                                                                          starting_offset);
+            auto out = std::make_shared<Core::Crypto::CTREncryptionLayer>(
+                std::move(in), key.value(), starting_offset);
            std::vector<u8> iv(16);
            for (u8 i = 0; i < 8; ++i)
                iv[i] = s_header.raw.section_ctr[0x8 - i - 1];
@@ -491,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;
 }
@@ -545,4 +519,7 @@ u64 NCA::GetBaseIVFCOffset() const {
    return ivfc_offset;
 }

+bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys
@@ -6,10 +6,9 @@

 #include <array>
 #include <memory>
-#include <optional>
 #include <string>
 #include <vector>
-
+#include <boost/optional.hpp>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -74,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 {
@@ -101,20 +102,14 @@ public:
    // Returns the base ivfc offset used in BKTR patching.
    u64 GetBaseIVFCOffset() const;

+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;
-    std::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
-    std::optional<Core::Crypto::Key128> GetTitlekey();
-    VirtualFile Decrypt(const NCASectionHeader& header, VirtualFile in, u64 starting_offset);
+    boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
+    boost::optional<Core::Crypto::Key128> GetTitlekey();
+    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset);

    std::vector<VirtualDir> dirs;
    std::vector<VirtualFile> files;
@@ -123,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;
 };
@@ -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
@@ -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:
@@ -27,6 +27,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <boost/detail/container_fwd.hpp>
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"

@@ -99,16 +99,16 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
            u16 rle_size{};
            if (ips->ReadObject(&rle_size, offset) != sizeof(u16))
                return nullptr;
-            rle_size = Common::swap16(rle_size);
+            rle_size = Common::swap16(data_size);
            offset += sizeof(u16);

            const auto data = ips->ReadByte(offset++);
-            if (!data)
+            if (data == boost::none)
                return nullptr;

            if (real_offset + rle_size > in_data.size())
                rle_size = static_cast<u16>(in_data.size() - real_offset);
-            std::memset(in_data.data() + real_offset, *data, rle_size);
+            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())
@@ -83,7 +83,7 @@ std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
 }

 std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
-    return {};
+    return pfs_dirs;
 }

 std::string PartitionFilesystem::GetName() const {
@@ -103,4 +103,18 @@ void PartitionFilesystem::PrintDebugInfo() const {
                  pfs_files[i]->GetName(), pfs_files[i]->GetSize());
    }
 }
+
+bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    const auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
+    if (iter == pfs_files.end())
+        return false;
+
+    const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
+    pfs_files[offset] = std::move(pfs_files.back());
+    pfs_files.pop_back();
+
+    pfs_dirs.emplace_back(std::move(dir));
+
+    return true;
+}
 } // namespace FileSys
@@ -35,6 +35,9 @@ public:
    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
    void PrintDebugInfo() const;

+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
    struct Header {
        u32_le magic;
@@ -81,6 +84,7 @@ private:
    std::size_t content_offset = 0;

    std::vector<VirtualFile> pfs_files;
+    std::vector<VirtualDir> pfs_dirs;
 };

 } // namespace FileSys
@@ -61,12 +61,13 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
    const auto update = installed->GetEntry(update_tid, ContentRecordType::Program);
-
-    if (update != nullptr && update->GetExeFS() != nullptr &&
-        update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
-        exefs = update->GetExeFS();
+    if (update != nullptr) {
+        if (update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
+            update->GetExeFS() != nullptr) {
+            LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
+                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
+            exefs = update->GetExeFS();
+        }
    }

    return exefs;
@@ -167,8 +168,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {

 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
-        load_dir == nullptr || load_dir->GetSize() <= 0) {
+    if (type != ContentRecordType::Program || load_dir == nullptr || load_dir->GetSize() <= 0) {
        return;
    }

@@ -214,14 +214,8 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t

 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 || type == ContentRecordType::Data)
-        LOG_INFO(Loader, log_string);
-    else
-        LOG_DEBUG(Loader, log_string);
+    LOG_INFO(Loader, "Patching RomFS for title_id={:016X}, type={:02X}", title_id,
+             static_cast<u8>(type));

    if (romfs == nullptr)
        return romfs;
@@ -236,7 +230,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
            new_nca->GetRomFS() != nullptr) {
            LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
+                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
            romfs = new_nca->GetRomFS();
        }
    } else if (update_raw != nullptr) {
@@ -280,11 +274,12 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
    } else {
        if (installed->HasEntry(update_tid, ContentRecordType::Program)) {
            const auto meta_ver = installed->GetEntryVersion(update_tid);
-            if (meta_ver.value_or(0) == 0) {
+            if (meta_ver == boost::none || meta_ver.get() == 0) {
                out.insert_or_assign("Update", "");
            } else {
                out.insert_or_assign(
-                    "Update", FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
+                    "Update",
+                    FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements));
            }
        } else if (update_raw != nullptr) {
            out.insert_or_assign("Update", "PACKED");
@@ -351,7 +346,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 }

 std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
-    const auto installed{Service::FileSystem::GetUnionContents()};
+    const auto& installed{Service::FileSystem::GetUnionContents()};

    const auto base_control_nca = installed->GetEntry(title_id, ContentRecordType::Control);
    if (base_control_nca == nullptr)
@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <algorithm>
 #include <regex>
 #include <mbedtls/sha256.h>
 #include "common/assert.h"
@@ -31,14 +30,6 @@ bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs)
    return (lhs.title_id < rhs.title_id) || (lhs.title_id == rhs.title_id && lhs.type < rhs.type);
 }

-bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
-    return std::tie(lhs.title_id, lhs.type) == std::tie(rhs.title_id, rhs.type);
-}
-
-bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
-    return !operator==(lhs, rhs);
-}
-
 static bool FollowsTwoDigitDirFormat(std::string_view name) {
    static const std::regex two_digit_regex("000000[0-9A-F]{2}", std::regex_constants::ECMAScript |
                                                                     std::regex_constants::icase);
@@ -159,28 +150,28 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
    return file;
 }

-static std::optional<NcaID> CheckMapForContentRecord(
+static boost::optional<NcaID> CheckMapForContentRecord(
    const boost::container::flat_map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
    if (map.find(title_id) == map.end())
-        return {};
+        return boost::none;

    const auto& cnmt = map.at(title_id);

    const auto iter = std::find_if(cnmt.GetContentRecords().begin(), cnmt.GetContentRecords().end(),
                                   [type](const ContentRecord& rec) { return rec.type == type; });
    if (iter == cnmt.GetContentRecords().end())
-        return {};
+        return boost::none;

-    return std::make_optional(iter->nca_id);
+    return boost::make_optional(iter->nca_id);
 }

-std::optional<NcaID> RegisteredCache::GetNcaIDFromMetadata(u64 title_id,
-                                                           ContentRecordType type) const {
+boost::optional<NcaID> RegisteredCache::GetNcaIDFromMetadata(u64 title_id,
+                                                             ContentRecordType type) const {
    if (type == ContentRecordType::Meta && meta_id.find(title_id) != meta_id.end())
        return meta_id.at(title_id);

    const auto res1 = CheckMapForContentRecord(yuzu_meta, title_id, type);
-    if (res1)
+    if (res1 != boost::none)
        return res1;
    return CheckMapForContentRecord(meta, title_id, type);
 }
@@ -283,14 +274,17 @@ bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {

 VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
    const auto id = GetNcaIDFromMetadata(title_id, type);
-    return id ? GetFileAtID(*id) : nullptr;
+    if (id == boost::none)
+        return nullptr;
+
+    return GetFileAtID(id.get());
 }

 VirtualFile RegisteredCache::GetEntryUnparsed(RegisteredCacheEntry entry) const {
    return GetEntryUnparsed(entry.title_id, entry.type);
 }

-std::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
+boost::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
    const auto meta_iter = meta.find(title_id);
    if (meta_iter != meta.end())
        return meta_iter->second.GetTitleVersion();
@@ -299,26 +293,29 @@ std::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
    if (yuzu_meta_iter != yuzu_meta.end())
        return yuzu_meta_iter->second.GetTitleVersion();

-    return {};
+    return boost::none;
 }

 VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) const {
    const auto id = GetNcaIDFromMetadata(title_id, type);
-    return id ? parser(GetFileAtID(*id), *id) : nullptr;
+    if (id == boost::none)
+        return nullptr;
+
+    return parser(GetFileAtID(id.get()), id.get());
 }

 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);
 }

@@ -358,8 +355,8 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntries() const {
 }

 std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
-    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
-    std::optional<u64> title_id) const {
+    boost::optional<TitleType> title_type, boost::optional<ContentRecordType> record_type,
+    boost::optional<u64> title_id) const {
    std::vector<RegisteredCacheEntry> out;
    IterateAllMetadata<RegisteredCacheEntry>(
        out,
@@ -367,11 +364,11 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
            return RegisteredCacheEntry{c.GetTitleID(), r.type};
        },
        [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
-            if (title_type && *title_type != c.GetType())
+            if (title_type != boost::none && title_type.get() != c.GetType())
                return false;
-            if (record_type && *record_type != r.type)
+            if (record_type != boost::none && record_type.get() != r.type)
                return false;
-            if (title_id && *title_id != c.GetTitleID())
+            if (title_id != boost::none && title_id.get() != c.GetTitleID())
                return false;
            return true;
        });
@@ -453,7 +450,7 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NCA> nca, TitleType

 InstallResult RegisteredCache::RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
                                             bool overwrite_if_exists,
-                                             std::optional<NcaID> override_id) {
+                                             boost::optional<NcaID> override_id) {
    const auto in = nca->GetBaseFile();
    Core::Crypto::SHA256Hash hash{};

@@ -462,12 +459,12 @@ InstallResult RegisteredCache::RawInstallNCA(std::shared_ptr<NCA> nca, const Vfs
    // game is massive), we're going to cheat and only hash the first MB of the NCA.
    // Also, for XCIs the NcaID matters, so if the override id isn't none, use that.
    NcaID id{};
-    if (override_id) {
-        id = *override_id;
-    } else {
+    if (override_id == boost::none) {
        const auto& data = in->ReadBytes(0x100000);
        mbedtls_sha256(data.data(), data.size(), hash.data(), 0);
        memcpy(id.data(), hash.data(), 16);
+    } else {
+        id = override_id.get();
    }

    std::string path = GetRelativePathFromNcaID(id, false, true);
@@ -519,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() {
@@ -537,14 +534,14 @@ bool RegisteredCacheUnion::HasEntry(RegisteredCacheEntry entry) const {
    return HasEntry(entry.title_id, entry.type);
 }

-std::optional<u32> RegisteredCacheUnion::GetEntryVersion(u64 title_id) const {
+boost::optional<u32> RegisteredCacheUnion::GetEntryVersion(u64 title_id) const {
    for (const auto& c : caches) {
        const auto res = c->GetEntryVersion(title_id);
-        if (res)
+        if (res != boost::none)
            return res;
    }

-    return {};
+    return boost::none;
 }

 VirtualFile RegisteredCacheUnion::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
@@ -575,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);
 }

@@ -596,15 +593,12 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
            },
            [](const CNMT& c, const ContentRecord& r) { return true; });
    }
-
-    std::sort(out.begin(), out.end());
-    out.erase(std::unique(out.begin(), out.end()), out.end());
    return out;
 }

 std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
-    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
-    std::optional<u64> title_id) const {
+    boost::optional<TitleType> title_type, boost::optional<ContentRecordType> record_type,
+    boost::optional<u64> title_id) const {
    std::vector<RegisteredCacheEntry> out;
    for (const auto& c : caches) {
        c->IterateAllMetadata<RegisteredCacheEntry>(
@@ -613,18 +607,15 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
                return RegisteredCacheEntry{c.GetTitleID(), r.type};
            },
            [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
-                if (title_type && *title_type != c.GetType())
+                if (title_type != boost::none && title_type.get() != c.GetType())
                    return false;
-                if (record_type && *record_type != r.type)
+                if (record_type != boost::none && record_type.get() != r.type)
                    return false;
-                if (title_id && *title_id != c.GetTitleID())
+                if (title_id != boost::none && title_id.get() != c.GetTitleID())
                    return false;
                return true;
            });
    }
-
-    std::sort(out.begin(), out.end());
-    out.erase(std::unique(out.begin(), out.end()), out.end());
    return out;
 }
 } // namespace FileSys
@@ -50,10 +50,6 @@ constexpr u64 GetUpdateTitleID(u64 base_title_id) {
 // boost flat_map requires operator< for O(log(n)) lookups.
 bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);

-// std unique requires operator== to identify duplicates.
-bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
-bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
-
 /*
 * A class that catalogues NCAs in the registered directory structure.
 * Nintendo's registered format follows this structure:
@@ -64,8 +60,8 @@ bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs
 *         | 00
 *         | 01 <- Actual content split along 4GB boundaries. (optional)
 *
- * (This impl also supports substituting the nca dir for an nca file, as that's more convenient
- * when 4GB splitting can be ignored.)
+ * (This impl also supports substituting the nca dir for an nca file, as that's more convenient when
+ * 4GB splitting can be ignored.)
 */
 class RegisteredCache {
    friend class RegisteredCacheUnion;
@@ -84,7 +80,7 @@ public:
    bool HasEntry(u64 title_id, ContentRecordType type) const;
    bool HasEntry(RegisteredCacheEntry entry) const;

-    std::optional<u32> GetEntryVersion(u64 title_id) const;
+    boost::optional<u32> GetEntryVersion(u64 title_id) const;

    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
@@ -92,14 +88,15 @@ 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 std::nullopt, it will be filtered for from all entries.
+    // If a parameter is not boost::none, it will be filtered for from all entries.
    std::vector<RegisteredCacheEntry> ListEntriesFilter(
-        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
-        std::optional<u64> title_id = {}) const;
+        boost::optional<TitleType> title_type = boost::none,
+        boost::optional<ContentRecordType> record_type = boost::none,
+        boost::optional<u64> title_id = boost::none) const;

    // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
    // there is a meta NCA and all of them are accessible.
@@ -124,11 +121,12 @@ private:
    std::vector<NcaID> AccumulateFiles() const;
    void ProcessFiles(const std::vector<NcaID>& ids);
    void AccumulateYuzuMeta();
-    std::optional<NcaID> GetNcaIDFromMetadata(u64 title_id, ContentRecordType type) const;
+    boost::optional<NcaID> GetNcaIDFromMetadata(u64 title_id, ContentRecordType type) const;
    VirtualFile GetFileAtID(NcaID id) const;
    VirtualFile OpenFileOrDirectoryConcat(const VirtualDir& dir, std::string_view path) const;
    InstallResult RawInstallNCA(std::shared_ptr<NCA> nca, const VfsCopyFunction& copy,
-                                bool overwrite_if_exists, std::optional<NcaID> override_id = {});
+                                bool overwrite_if_exists,
+                                boost::optional<NcaID> override_id = boost::none);
    bool RawInstallYuzuMeta(const CNMT& cnmt);

    VirtualDir dir;
@@ -144,14 +142,14 @@ 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();

    bool HasEntry(u64 title_id, ContentRecordType type) const;
    bool HasEntry(RegisteredCacheEntry entry) const;

-    std::optional<u32> GetEntryVersion(u64 title_id) const;
+    boost::optional<u32> GetEntryVersion(u64 title_id) const;

    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
@@ -159,17 +157,18 @@ 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 std::nullopt, it will be filtered for from all entries.
+    // If a parameter is not boost::none, it will be filtered for from all entries.
    std::vector<RegisteredCacheEntry> ListEntriesFilter(
-        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
-        std::optional<u64> title_id = {}) const;
+        boost::optional<TitleType> title_type = boost::none,
+        boost::optional<ContentRecordType> record_type = boost::none,
+        boost::optional<u64> title_id = boost::none) const;

 private:
-    std::vector<RegisteredCache*> caches;
+    std::vector<std::shared_ptr<RegisteredCache>> caches;
 };

 } // namespace FileSys
@@ -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));
@@ -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
@@ -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
@@ -205,6 +205,10 @@ VirtualDir NSP::GetParentDirectory() const {
    return file->GetContainingDirectory();
 }

+bool NSP::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
 void NSP::InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files) {
    exefs = pfs;

@@ -55,6 +55,9 @@ public:

    VirtualDir GetParentDirectory() const override;

+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
    void InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files);
    void ReadNCAs(const std::vector<VirtualFile>& files);
@@ -167,13 +167,13 @@ std::string VfsFile::GetExtension() const {

 VfsDirectory::~VfsDirectory() = default;

-std::optional<u8> VfsFile::ReadByte(std::size_t offset) const {
+boost::optional<u8> VfsFile::ReadByte(std::size_t offset) const {
    u8 out{};
    std::size_t size = Read(&out, 1, offset);
    if (size == 1)
        return out;

-    return {};
+    return boost::none;
 }

 std::vector<u8> VfsFile::ReadBytes(std::size_t size, std::size_t offset) const {
@@ -472,14 +472,10 @@ bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t blo
    std::vector<u8> temp(std::min(block_size, src->GetSize()));
    for (std::size_t i = 0; i < src->GetSize(); i += block_size) {
        const auto read = std::min(block_size, src->GetSize() - i);
+        const auto block = src->Read(temp.data(), read, i);

-        if (src->Read(temp.data(), read, i) != read) {
+        if (dest->Write(temp.data(), read, i) != read)
            return false;
-        }
-
-        if (dest->Write(temp.data(), read, i) != read) {
-            return false;
-        }
    }

    return true;
@@ -4,22 +4,28 @@

 #pragma once

-#include <functional>
 #include <map>
 #include <memory>
-#include <optional>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #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,
@@ -105,8 +111,8 @@ public:
    // into file. Returns number of bytes successfully written.
    virtual std::size_t Write(const u8* data, std::size_t length, std::size_t offset = 0) = 0;

-    // Reads exactly one byte at the offset provided, returning std::nullopt on error.
-    virtual std::optional<u8> ReadByte(std::size_t offset = 0) const;
+    // Reads exactly one byte at the offset provided, returning boost::none on error.
+    virtual boost::optional<u8> ReadByte(std::size_t offset = 0) const;
    // Reads size bytes starting at offset in file into a vector.
    virtual std::vector<u8> ReadBytes(std::size_t size, std::size_t offset = 0) const;
    // Reads all the bytes from the file into a vector. Equivalent to 'file->Read(file->GetSize(),
@@ -264,8 +270,36 @@ public:
    // item name -> type.
    virtual std::map<std::string, VfsEntryType, std::less<>> GetEntries() const;

+    // Interprets the file with name file instead as a directory of type directory.
+    // The directory must have a constructor that takes a single argument of type
+    // std::shared_ptr<VfsFile>. Allows to reinterpret container files (i.e NCA, zip, XCI, etc) as a
+    // subdirectory in one call.
+    template <typename Directory>
+    bool InterpretAsDirectory(std::string_view file) {
+        auto file_p = GetFile(file);
+
+        if (file_p == nullptr) {
+            return false;
+        }
+
+        return ReplaceFileWithSubdirectory(file_p, std::make_shared<Directory>(file_p));
+    }
+
+    bool InterpretAsDirectory(const std::function<VirtualDir(VirtualFile)>& function,
+                              const std::string& file) {
+        auto file_p = GetFile(file);
+        if (file_p == nullptr)
+            return false;
+        return ReplaceFileWithSubdirectory(file_p, function(file_p));
+    }
+
    // Returns the full path of this directory as a string, recursively
    virtual std::string GetFullPath() const;
+
+protected:
+    // Backend for InterpretAsDirectory.
+    // Removes all references to file and adds a reference to dir in the directory's implementation.
+    virtual bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) = 0;
 };

 // A convenience partial-implementation of VfsDirectory that stubs out methods that should only work
@@ -126,4 +126,7 @@ bool LayeredVfsDirectory::Rename(std::string_view name_) {
    return true;
 }

+bool LayeredVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys
@@ -39,6 +39,9 @@ public:
    bool DeleteFile(std::string_view name) override;
    bool Rename(std::string_view name) override;

+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
    std::vector<VirtualDir> dirs;
    std::string name;
@@ -57,11 +57,11 @@ std::size_t OffsetVfsFile::Write(const u8* data, std::size_t length, std::size_t
    return file->Write(data, TrimToFit(length, r_offset), offset + r_offset);
 }

-std::optional<u8> OffsetVfsFile::ReadByte(std::size_t r_offset) const {
+boost::optional<u8> OffsetVfsFile::ReadByte(std::size_t r_offset) const {
    if (r_offset < size)
        return file->ReadByte(offset + r_offset);

-    return {};
+    return boost::none;
 }

 std::vector<u8> OffsetVfsFile::ReadBytes(std::size_t r_size, std::size_t r_offset) const {
@@ -29,7 +29,7 @@ public:
    bool IsReadable() const override;
    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
    std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override;
-    std::optional<u8> ReadByte(std::size_t offset) const override;
+    boost::optional<u8> ReadByte(std::size_t offset) const override;
    std::vector<u8> ReadBytes(std::size_t size, std::size_t offset) const override;
    std::vector<u8> ReadAllBytes() const override;
    bool WriteByte(u8 data, std::size_t offset) override;
@@ -430,4 +430,7 @@ std::map<std::string, VfsEntryType, std::less<>> RealVfsDirectory::GetEntries()
    return out;
 }

+bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys
@@ -100,6 +100,9 @@ public:
    std::string GetFullPath() const override;
    std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;

+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read);

@@ -53,10 +53,10 @@ public:
        return 0;
    }

-    std::optional<u8> ReadByte(std::size_t offset) const override {
+    boost::optional<u8> ReadByte(std::size_t offset) const override {
        if (offset < size)
            return value;
-        return {};
+        return boost::none;
    }

    std::vector<u8> ReadBytes(std::size_t length, std::size_t offset) const override {
@@ -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
@@ -132,4 +132,11 @@ void VectorVfsDirectory::AddFile(VirtualFile file) {
 void VectorVfsDirectory::AddDirectory(VirtualDir dir) {
    dirs.push_back(std::move(dir));
 }
+
+bool VectorVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    if (!DeleteFile(file->GetName()))
+        return false;
+    dirs.emplace_back(std::move(dir));
+    return true;
+}
 } // namespace FileSys
@@ -57,6 +57,9 @@ public:
    virtual void AddFile(VirtualFile file);
    virtual void AddDirectory(VirtualDir dir);

+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
    std::vector<VirtualFile> files;
    std::vector<VirtualDir> dirs;
@@ -163,4 +163,7 @@ std::shared_ptr<VfsDirectory> NAX::GetParentDirectory() const {
    return file->GetContainingDirectory();
 }

+bool NAX::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys
@@ -51,6 +51,9 @@ public:

    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;

+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
    Loader::ResultStatus Parse(std::string_view path);

@@ -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>)*",
@@ -14,6 +14,11 @@ namespace IPC {
 /// Size of the command buffer area, in 32-bit words.
 constexpr std::size_t COMMAND_BUFFER_LENGTH = 0x100 / sizeof(u32);

+// These errors are commonly returned by invalid IPC translations, so alias them here for
+// convenience.
+// TODO(yuriks): These will probably go away once translation is implemented inside the kernel.
+constexpr auto ERR_INVALID_HANDLE = Kernel::ERR_INVALID_HANDLE_OS;
+
 enum class ControlCommand : u32 {
    ConvertSessionToDomain = 0,
    ConvertDomainToSession = 1,
@@ -117,7 +117,8 @@ public:

        AlignWithPadding();

-        if (context.Session()->IsDomain() && context.HasDomainMessageHeader()) {
+        const bool request_has_domain_header{context.GetDomainMessageHeader() != nullptr};
+        if (context.Session()->IsDomain() && request_has_domain_header) {
            IPC::DomainMessageHeader domain_header{};
            domain_header.num_objects = num_domain_objects;
            PushRaw(domain_header);
@@ -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)
@@ -10,6 +10,11 @@ namespace Kernel {

 namespace ErrCodes {
 enum {
+    // TODO(Subv): Remove these 3DS OS error codes.
+    SessionClosedByRemote = 26,
+    NoPendingSessions = 35,
+    InvalidBufferDescriptor = 48,
+
    // Confirmed Switch OS error codes
    MaxConnectionsReached = 7,
    InvalidSize = 101,
@@ -17,11 +22,9 @@ enum {
    HandleTableFull = 105,
    InvalidMemoryState = 106,
    InvalidMemoryPermissions = 108,
-    InvalidMemoryRange = 110,
    InvalidThreadPriority = 112,
    InvalidProcessorId = 113,
    InvalidHandle = 114,
-    InvalidPointer = 115,
    InvalidCombination = 116,
    Timeout = 117,
    SynchronizationCanceled = 118,
@@ -29,7 +32,6 @@ enum {
    InvalidEnumValue = 120,
    NoSuchEntry = 121,
    AlreadyRegistered = 122,
-    SessionClosed = 123,
    InvalidState = 125,
    ResourceLimitExceeded = 132,
 };
@@ -38,19 +40,22 @@ enum {
 // WARNING: The kernel is quite inconsistent in it's usage of errors code. Make sure to always
 // double check that the code matches before re-using the constant.

+// TODO(bunnei): Replace -1 with correct errors for Switch OS
 constexpr ResultCode ERR_HANDLE_TABLE_FULL(ErrorModule::Kernel, ErrCodes::HandleTableFull);
-constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(ErrorModule::Kernel, ErrCodes::SessionClosed);
+constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(-1);
 constexpr ResultCode ERR_PORT_NAME_TOO_LONG(ErrorModule::Kernel, ErrCodes::TooLarge);
 constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED(ErrorModule::Kernel,
                                                 ErrCodes::MaxConnectionsReached);
 constexpr ResultCode ERR_INVALID_ENUM_VALUE(ErrorModule::Kernel, ErrCodes::InvalidEnumValue);
+constexpr ResultCode ERR_INVALID_ENUM_VALUE_FND(-1);
+constexpr ResultCode ERR_INVALID_COMBINATION(-1);
 constexpr ResultCode ERR_INVALID_COMBINATION_KERNEL(ErrorModule::Kernel,
                                                    ErrCodes::InvalidCombination);
+constexpr ResultCode ERR_OUT_OF_MEMORY(-1);
 constexpr ResultCode ERR_INVALID_ADDRESS(ErrorModule::Kernel, ErrCodes::InvalidAddress);
 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);
@@ -58,8 +63,14 @@ constexpr ResultCode ERR_ALREADY_REGISTERED(ErrorModule::Kernel, ErrCodes::Alrea
 constexpr ResultCode ERR_INVALID_STATE(ErrorModule::Kernel, ErrCodes::InvalidState);
 constexpr ResultCode ERR_INVALID_THREAD_PRIORITY(ErrorModule::Kernel,
                                                 ErrCodes::InvalidThreadPriority);
-constexpr ResultCode ERR_INVALID_POINTER(ErrorModule::Kernel, ErrCodes::InvalidPointer);
+constexpr ResultCode ERR_INVALID_POINTER(-1);
+constexpr ResultCode ERR_INVALID_OBJECT_ADDR(-1);
+constexpr ResultCode ERR_NOT_AUTHORIZED(-1);
+/// Alternate code returned instead of ERR_INVALID_HANDLE in some code paths.
+constexpr ResultCode ERR_INVALID_HANDLE_OS(-1);
 constexpr ResultCode ERR_NOT_FOUND(ErrorModule::Kernel, ErrCodes::NoSuchEntry);
 constexpr ResultCode RESULT_TIMEOUT(ErrorModule::Kernel, ErrCodes::Timeout);
+/// Returned when Accept() is called on a port with no sessions to be accepted.
+constexpr ResultCode ERR_NO_PENDING_SESSIONS(-1);

 } // namespace Kernel
@@ -77,8 +77,7 @@ HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_ses

 HLERequestContext::~HLERequestContext() = default;

-void HLERequestContext::ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf,
-                                           bool incoming) {
+void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
    IPC::RequestParser rp(src_cmdbuf);
    command_header = std::make_shared<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>());

@@ -95,6 +94,8 @@ void HLERequestContext::ParseCommandBuffer(const HandleTable& handle_table, u32_
            rp.Skip(2, false);
        }
        if (incoming) {
+            auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
+
            // Populate the object lists with the data in the IPC request.
            for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
                copy_objects.push_back(handle_table.GetGeneric(rp.Pop<Handle>()));
@@ -188,9 +189,10 @@ void HLERequestContext::ParseCommandBuffer(const HandleTable& handle_table, u32_
    rp.Skip(1, false); // The command is actually an u64, but we don't use the high part.
 }

-ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
-                                                                u32_le* src_cmdbuf) {
-    ParseCommandBuffer(handle_table, src_cmdbuf, true);
+ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf,
+                                                                Process& src_process,
+                                                                HandleTable& src_table) {
+    ParseCommandBuffer(src_cmdbuf, true);
    if (command_header->type == IPC::CommandType::Close) {
        // Close does not populate the rest of the IPC header
        return RESULT_SUCCESS;
@@ -205,17 +207,14 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const HandleTabl
    return RESULT_SUCCESS;
 }

-ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
-    auto& owner_process = *thread.GetOwnerProcess();
-    auto& handle_table = owner_process.GetHandleTable();
-
+ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread) {
    std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
-    Memory::ReadBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::ReadBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
                      dst_cmdbuf.size() * sizeof(u32));

    // The header was already built in the internal command buffer. Attempt to parse it to verify
    // the integrity and then copy it over to the target command buffer.
-    ParseCommandBuffer(handle_table, cmd_buf.data(), false);
+    ParseCommandBuffer(cmd_buf.data(), false);

    // The data_size already includes the payload header, the padding and the domain header.
    std::size_t size = data_payload_offset + command_header->data_size -
@@ -237,6 +236,8 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
        ASSERT(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
        ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);

+        auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
+
        // We don't make a distinction between copy and move handles when translating since HLE
        // services don't deal with handles directly. However, the guest applications might check
        // for specific values in each of these descriptors.
@@ -267,7 +268,7 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
    }

    // Copy the translated command buffer back into the thread's command buffer area.
-    Memory::WriteBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::WriteBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
                       dst_cmdbuf.size() * sizeof(u32));

    return RESULT_SUCCESS;
@@ -24,10 +24,10 @@ class ServiceFrameworkBase;
 namespace Kernel {

 class Domain;
-class Event;
 class HandleTable;
 class HLERequestContext;
 class Process;
+class Event;

 /**
 * Interface implemented by HLE Session handlers.
@@ -126,12 +126,13 @@ public:
                                       u64 timeout, WakeupCallback&& callback,
                                       Kernel::SharedPtr<Kernel::Event> event = nullptr);

-    /// Populates this context with data from the requesting process/thread.
-    ResultCode PopulateFromIncomingCommandBuffer(const HandleTable& handle_table,
-                                                 u32_le* src_cmdbuf);
+    void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);

+    /// Populates this context with data from the requesting process/thread.
+    ResultCode PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf, Process& src_process,
+                                                 HandleTable& src_table);
    /// Writes data from this context back to the requesting process/thread.
-    ResultCode WriteToOutgoingCommandBuffer(Thread& thread);
+    ResultCode WriteToOutgoingCommandBuffer(const Thread& thread);

    u32_le GetCommand() const {
        return command;
@@ -161,12 +162,8 @@ public:
        return buffer_c_desciptors;
    }

-    const IPC::DomainMessageHeader* GetDomainMessageHeader() const {
-        return domain_message_header.get();
-    }
-
-    bool HasDomainMessageHeader() const {
-        return domain_message_header != nullptr;
+    const std::shared_ptr<IPC::DomainMessageHeader>& GetDomainMessageHeader() const {
+        return domain_message_header;
    }

    /// Helper function to read a buffer using the appropriate buffer descriptor
@@ -258,8 +255,6 @@ public:
    std::string Description() const;

 private:
-    void ParseCommandBuffer(const HandleTable& handle_table, u32_le* src_cmdbuf, bool incoming);
-
    std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
    SharedPtr<Kernel::ServerSession> server_session;
    // TODO(yuriks): Check common usage of this and optimize size accordingly
@@ -32,7 +32,7 @@ namespace Kernel {
 */
 static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_late) {
    const auto proper_handle = static_cast<Handle>(thread_handle);
-    const auto& system = Core::System::GetInstance();
+    auto& system = Core::System::GetInstance();

    // Lock the global kernel mutex when we enter the kernel HLE.
    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
@@ -90,7 +90,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_
 /// The timer callback event, called when a timer is fired
 static void TimerCallback(u64 timer_handle, int cycles_late) {
    const auto proper_handle = static_cast<Handle>(timer_handle);
-    const auto& system = Core::System::GetInstance();
+    auto& system = Core::System::GetInstance();
    SharedPtr<Timer> timer = system.Kernel().RetrieveTimerFromCallbackHandleTable(proper_handle);

    if (timer == nullptr) {
@@ -118,6 +118,7 @@ struct KernelCore::Impl {
        process_list.clear();
        current_process = nullptr;

+        handle_table.Clear();
        resource_limits.fill(nullptr);

        thread_wakeup_callback_handle_table.Clear();
@@ -208,6 +209,7 @@ struct KernelCore::Impl {
    std::vector<SharedPtr<Process>> process_list;
    Process* current_process = nullptr;

+    Kernel::HandleTable handle_table;
    std::array<SharedPtr<ResourceLimit>, 4> resource_limits;

    /// The event type of the generic timer callback event
@@ -239,6 +241,14 @@ void KernelCore::Shutdown() {
    impl->Shutdown();
 }

+Kernel::HandleTable& KernelCore::HandleTable() {
+    return impl->handle_table;
+}
+
+const Kernel::HandleTable& KernelCore::HandleTable() const {
+    return impl->handle_table;
+}
+
 SharedPtr<ResourceLimit> KernelCore::ResourceLimitForCategory(
    ResourceLimitCategory category) const {
    return impl->resource_limits.at(static_cast<std::size_t>(category));
@@ -47,6 +47,12 @@ public:
    /// Clears all resources in use by the kernel instance.
    void Shutdown();

+    /// Provides a reference to the handle table.
+    Kernel::HandleTable& HandleTable();
+
+    /// Provides a const reference to the handle table.
+    const Kernel::HandleTable& HandleTable() const;
+
    /// Retrieves a shared pointer to a ResourceLimit identified by the given category.
    SharedPtr<ResourceLimit> ResourceLimitForCategory(ResourceLimitCategory category) const;

@@ -6,6 +6,8 @@
 #include <utility>
 #include <vector>

+#include <boost/range/algorithm_ext/erase.hpp>
+
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
@@ -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;
@@ -26,6 +26,7 @@ enum class HandleType : u32 {
    AddressArbiter,
    Timer,
    ResourceLimit,
+    CodeSet,
    ClientPort,
    ServerPort,
    ClientSession,
@@ -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,26 +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);
-
-    // Clear instruction cache in CPU JIT
-    Core::System::GetInstance().ArmInterface(0).ClearInstructionCache();
-    Core::System::GetInstance().ArmInterface(1).ClearInstructionCache();
-    Core::System::GetInstance().ArmInterface(2).ClearInstructionCache();
-    Core::System::GetInstance().ArmInterface(3).ClearInstructionCache();
+    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) {
@@ -295,7 +295,7 @@ ResultCode Process::HeapFree(VAddr target, u32 size) {
    return RESULT_SUCCESS;
 }

-ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
+ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, MemoryState state) {
    auto vma = vm_manager.FindVMA(src_addr);

    ASSERT_MSG(vma != vm_manager.vma_map.end(), "Invalid memory address");
@@ -311,7 +311,7 @@ ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {

    CASCADE_RESULT(auto new_vma,
                   vm_manager.MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size,
-                                             MemoryState::Mapped));
+                                             state));
    // Protect mirror with permissions from old region
    vm_manager.Reprotect(new_vma, vma->second.permissions);
    // Remove permissions from old region
@@ -13,7 +13,6 @@
 #include <boost/container/static_vector.hpp>
 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
@@ -25,7 +24,6 @@ class ProgramMetadata;
 namespace Kernel {

 class KernelCore;
-class ResourceLimit;

 struct AddressMapping {
    // Address and size must be page-aligned
@@ -59,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];
@@ -114,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 {
@@ -143,16 +145,6 @@ public:
        return vm_manager;
    }

-    /// Gets a reference to the process' handle table.
-    HandleTable& GetHandleTable() {
-        return handle_table;
-    }
-
-    /// Gets a const reference to the process' handle table.
-    const HandleTable& GetHandleTable() const {
-        return handle_table;
-    }
-
    /// Gets the current status of the process
    ProcessStatus GetStatus() const {
        return status;
@@ -202,16 +194,6 @@ public:
        return is_64bit_process;
    }

-    /// Gets the total running time of the process instance in ticks.
-    u64 GetCPUTimeTicks() const {
-        return total_process_running_time_ticks;
-    }
-
-    /// Updates the total running time, adding the given ticks to it.
-    void UpdateCPUTimeTicks(u64 ticks) {
-        total_process_running_time_ticks += ticks;
-    }
-
    /**
     * Loads process-specifics configuration info with metadata provided
     * by an executable.
@@ -237,7 +219,7 @@ public:
     */
    void PrepareForTermination();

-    void LoadModule(CodeSet module_, VAddr base_addr);
+    void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr);

    ///////////////////////////////////////////////////////////////////////////////////////////////
    // Memory Management
@@ -251,7 +233,8 @@ public:
    ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
    ResultCode HeapFree(VAddr target, u32 size);

-    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size,
+                            MemoryState state = MemoryState::Mapped);

    ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);

@@ -315,12 +298,6 @@ private:
    /// specified by metadata provided to the process during loading.
    bool is_64bit_process = true;

-    /// Total running time for the process in ticks.
-    u64 total_process_running_time_ticks = 0;
-
-    /// Per-process handle table for storing created object handles in.
-    HandleTable handle_table;
-
    std::string name;
 };

@@ -9,7 +9,6 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_timing.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
@@ -35,10 +34,6 @@ Thread* Scheduler::GetCurrentThread() const {
    return current_thread.get();
 }

-u64 Scheduler::GetLastContextSwitchTicks() const {
-    return last_context_switch_time;
-}
-
 Thread* Scheduler::PopNextReadyThread() {
    Thread* next = nullptr;
    Thread* thread = GetCurrentThread();
@@ -59,10 +54,7 @@ Thread* Scheduler::PopNextReadyThread() {
 }

 void Scheduler::SwitchContext(Thread* new_thread) {
-    Thread* const previous_thread = GetCurrentThread();
-    Process* const previous_process = Core::CurrentProcess();
-
-    UpdateLastContextSwitchTime(previous_thread, previous_process);
+    Thread* previous_thread = GetCurrentThread();

    // Save context for previous thread
    if (previous_thread) {
@@ -86,6 +78,8 @@ void Scheduler::SwitchContext(Thread* new_thread) {
        // Cancel any outstanding wakeup events for this thread
        new_thread->CancelWakeupTimer();

+        auto* const previous_process = Core::CurrentProcess();
+
        current_thread = new_thread;

        ready_queue.remove(new_thread->GetPriority(), new_thread);
@@ -108,22 +102,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
    }
 }

-void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
-    const u64 prev_switch_ticks = last_context_switch_time;
-    const u64 most_recent_switch_ticks = CoreTiming::GetTicks();
-    const u64 update_ticks = most_recent_switch_ticks - prev_switch_ticks;
-
-    if (thread != nullptr) {
-        thread->UpdateCPUTimeTicks(update_ticks);
-    }
-
-    if (process != nullptr) {
-        process->UpdateCPUTimeTicks(update_ticks);
-    }
-
-    last_context_switch_time = most_recent_switch_ticks;
-}
-
 void Scheduler::Reschedule() {
    std::lock_guard<std::mutex> lock(scheduler_mutex);

@@ -17,8 +17,6 @@ class ARM_Interface;

 namespace Kernel {

-class Process;
-
 class Scheduler final {
 public:
    explicit Scheduler(Core::ARM_Interface& cpu_core);
@@ -33,9 +31,6 @@ public:
    /// Gets the current running thread
    Thread* GetCurrentThread() const;

-    /// Gets the timestamp for the last context switch in ticks.
-    u64 GetLastContextSwitchTicks() const;
-
    /// Adds a new thread to the scheduler
    void AddThread(SharedPtr<Thread> thread, u32 priority);

@@ -69,19 +64,6 @@ private:
     */
    void SwitchContext(Thread* new_thread);

-    /**
-     * Called on every context switch to update the internal timestamp
-     * This also updates the running time ticks for the given thread and
-     * process using the following difference:
-     *
-     * ticks += most_recent_ticks - last_context_switch_ticks
-     *
-     * The internal tick timestamp for the scheduler is simply the
-     * most recent tick count retrieved. No special arithmetic is
-     * applied to it.
-     */
-    void UpdateLastContextSwitchTime(Thread* thread, Process* process);
-
    /// Lists all thread ids that aren't deleted/etc.
    std::vector<SharedPtr<Thread>> thread_list;

@@ -91,7 +73,6 @@ private:
    SharedPtr<Thread> current_thread = nullptr;

    Core::ARM_Interface& cpu_core;
-    u64 last_context_switch_time = 0;

    static std::mutex scheduler_mutex;
 };
@@ -18,7 +18,7 @@ ServerPort::~ServerPort() = default;

 ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {
    if (pending_sessions.empty()) {
-        return ERR_NOT_FOUND;
+        return ERR_NO_PENDING_SESSIONS;
    }

    auto session = std::move(pending_sessions.back());
@@ -28,7 +28,7 @@ ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {

 bool ServerPort::ShouldWait(Thread* thread) const {
    // If there are no pending sessions, we wait until a new one is added.
-    return pending_sessions.empty();
+    return pending_sessions.size() == 0;
 }

 void ServerPort::Acquire(Thread* thread) {
@@ -63,7 +63,7 @@ void ServerSession::Acquire(Thread* thread) {
 }

 ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
-    auto* const domain_message_header = context.GetDomainMessageHeader();
+    auto& domain_message_header = context.GetDomainMessageHeader();
    if (domain_message_header) {
        // Set domain handlers in HLE context, used for domain objects (IPC interfaces) as inputs
        context.SetDomainRequestHandlers(domain_request_handlers);
@@ -107,11 +107,12 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
    // similar.
    Kernel::HLERequestContext context(this);
    u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
-    context.PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
+    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(),
+                                              kernel.HandleTable());

    ResultCode result = RESULT_SUCCESS;
    // If the session has been converted to a domain, handle the domain request
-    if (IsDomain() && context.HasDomainMessageHeader()) {
+    if (IsDomain() && context.GetDomainMessageHeader()) {
        result = HandleDomainSyncRequest(context);
        // If there is no domain header, the regular session handler is used
    } else if (hle_handler != nullptr) {
@@ -80,19 +80,20 @@ SharedPtr<SharedMemory> SharedMemory::CreateForApplet(

 ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermission permissions,
                             MemoryPermission other_permissions) {
-    const MemoryPermission own_other_permissions =
+
+    MemoryPermission own_other_permissions =
        target_process == owner_process ? this->permissions : this->other_permissions;

    // Automatically allocated memory blocks can only be mapped with other_permissions = DontCare
    if (base_address == 0 && other_permissions != MemoryPermission::DontCare) {
-        return ERR_INVALID_MEMORY_PERMISSIONS;
+        return ERR_INVALID_COMBINATION;
    }

    // Error out if the requested permissions don't match what the creator process allows.
    if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
        LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
                  GetObjectId(), address, name);
-        return ERR_INVALID_MEMORY_PERMISSIONS;
+        return ERR_INVALID_COMBINATION;
    }

    // Error out if the provided permissions are not compatible with what the creator process needs.
@@ -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
@@ -189,15 +124,14 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
    CASCADE_RESULT(client_session, client_port->Connect());

    // Return the client session
-    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    CASCADE_RESULT(*out_handle, handle_table.Create(client_session));
+    CASCADE_RESULT(*out_handle, kernel.HandleTable().Create(client_session));
    return RESULT_SUCCESS;
 }

 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Handle handle) {
-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    SharedPtr<ClientSession> session = handle_table.Get<ClientSession>(handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    SharedPtr<ClientSession> session = kernel.HandleTable().Get<ClientSession>(handle);
    if (!session) {
        LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
        return ERR_INVALID_HANDLE;
@@ -216,8 +150,8 @@ static ResultCode SendSyncRequest(Handle handle) {
 static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
    LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -230,8 +164,8 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
    LOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
    if (!process) {
        return ERR_INVALID_HANDLE;
    }
@@ -274,11 +208,11 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64

    using ObjectPtr = Thread::ThreadWaitObjects::value_type;
    Thread::ThreadWaitObjects objects(handle_count);
-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    auto& kernel = Core::System::GetInstance().Kernel();

    for (u64 i = 0; i < handle_count; ++i) {
        const Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
-        const auto object = handle_table.Get<WaitObject>(handle);
+        const auto object = kernel.HandleTable().Get<WaitObject>(handle);

        if (object == nullptr) {
            return ERR_INVALID_HANDLE;
@@ -326,8 +260,8 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 static ResultCode CancelSynchronization(Handle thread_handle) {
    LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -351,11 +285,7 @@ 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::CurrentProcess()->GetHandleTable();
+    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
    return Mutex::TryAcquire(handle_table, mutex_addr, holding_thread_handle,
                             requesting_thread_handle);
 }
@@ -368,114 +298,30 @@ 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);
 }

-enum class BreakType : u32 {
-    Panic = 0,
-    AssertionFailed = 1,
-    PreNROLoad = 3,
-    PostNROLoad = 4,
-    PreNROUnload = 5,
-    PostNROUnload = 6,
-};
-
 struct BreakReason {
    union {
-        u32 raw;
-        BitField<0, 30, BreakType> break_type;
-        BitField<31, 1, u32> signal_debugger;
+        u64 raw;
+        BitField<31, 1, u64> dont_kill_application;
    };
 };

 /// Break program execution
-static void Break(u32 reason, u64 info1, u64 info2) {
+static void Break(u64 reason, u64 info1, u64 info2) {
    BreakReason break_reason{reason};
-    bool has_dumped_buffer{};
-
-    const auto handle_debug_buffer = [&](VAddr addr, u64 sz) {
-        if (sz == 0 || addr == 0 || has_dumped_buffer) {
-            return;
-        }
-
-        // This typically is an error code so we're going to assume this is the case
-        if (sz == sizeof(u32)) {
-            LOG_CRITICAL(Debug_Emulated, "debug_buffer_err_code={:X}", Memory::Read32(addr));
-        } else {
-            // We don't know what's in here so we'll hexdump it
-            std::vector<u8> debug_buffer(sz);
-            Memory::ReadBlock(addr, debug_buffer.data(), sz);
-            std::string hexdump;
-            for (std::size_t i = 0; i < debug_buffer.size(); i++) {
-                hexdump += fmt::format("{:02X} ", debug_buffer[i]);
-                if (i != 0 && i % 16 == 0) {
-                    hexdump += '\n';
-                }
-            }
-            LOG_CRITICAL(Debug_Emulated, "debug_buffer=\n{}", hexdump);
-        }
-        has_dumped_buffer = true;
-    };
-    switch (break_reason.break_type) {
-    case BreakType::Panic:
-        LOG_CRITICAL(Debug_Emulated, "Signalling debugger, PANIC! info1=0x{:016X}, info2=0x{:016X}",
-                     info1, info2);
-        handle_debug_buffer(info1, info2);
-        break;
-    case BreakType::AssertionFailed:
-        LOG_CRITICAL(Debug_Emulated,
-                     "Signalling debugger, Assertion failed! info1=0x{:016X}, info2=0x{:016X}",
-                     info1, info2);
-        handle_debug_buffer(info1, info2);
-        break;
-    case BreakType::PreNROLoad:
-        LOG_WARNING(
+    if (break_reason.dont_kill_application) {
+        LOG_ERROR(
            Debug_Emulated,
-            "Signalling debugger, Attempting to load an NRO at 0x{:016X} with size 0x{:016X}",
-            info1, info2);
-        break;
-    case BreakType::PostNROLoad:
-        LOG_WARNING(Debug_Emulated,
-                    "Signalling debugger, Loaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
-                    info2);
-        break;
-    case BreakType::PreNROUnload:
-        LOG_WARNING(
-            Debug_Emulated,
-            "Signalling debugger, Attempting to unload an NRO at 0x{:016X} with size 0x{:016X}",
-            info1, info2);
-        break;
-    case BreakType::PostNROUnload:
-        LOG_WARNING(Debug_Emulated,
-                    "Signalling debugger, Unloaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
-                    info2);
-        break;
-    default:
-        LOG_WARNING(
-            Debug_Emulated,
-            "Signalling debugger, Unknown break reason {}, info1=0x{:016X}, info2=0x{:016X}",
-            static_cast<u32>(break_reason.break_type.Value()), info1, info2);
-        handle_debug_buffer(info1, info2);
-        break;
-    }
-
-    if (!break_reason.signal_debugger) {
+            "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);
-        handle_debug_buffer(info1, info2);
        ASSERT(false);
-
-        Core::CurrentProcess()->PrepareForTermination();
-
-        // Kill the current thread
-        GetCurrentThread()->Stop();
-        Core::System::GetInstance().PrepareReschedule();
    }
 }

@@ -495,37 +341,6 @@ 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);

-    enum class GetInfoType : u64 {
-        // 1.0.0+
-        AllowedCpuIdBitmask = 0,
-        AllowedThreadPrioBitmask = 1,
-        MapRegionBaseAddr = 2,
-        MapRegionSize = 3,
-        HeapRegionBaseAddr = 4,
-        HeapRegionSize = 5,
-        TotalMemoryUsage = 6,
-        TotalHeapUsage = 7,
-        IsCurrentProcessBeingDebugged = 8,
-        ResourceHandleLimit = 9,
-        IdleTickCount = 10,
-        RandomEntropy = 11,
-        PerformanceCounter = 0xF0000002,
-        // 2.0.0+
-        ASLRRegionBaseAddr = 12,
-        ASLRRegionSize = 13,
-        NewMapRegionBaseAddr = 14,
-        NewMapRegionSize = 15,
-        // 3.0.0+
-        IsVirtualAddressMemoryEnabled = 16,
-        PersonalMmHeapUsage = 17,
-        TitleId = 18,
-        // 4.0.0+
-        PrivilegedProcessId = 19,
-        // 5.0.0+
-        UserExceptionContextAddr = 20,
-        ThreadTickCount = 0xF0000002,
-    };
-
    const auto* current_process = Core::CurrentProcess();
    const auto& vm_manager = current_process->VMManager();

@@ -560,12 +375,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;
@@ -588,36 +416,6 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
                    "(STUBBED) Attempted to query user exception context address, returned 0");
        *result = 0;
        break;
-    case GetInfoType::ThreadTickCount: {
-        constexpr u64 num_cpus = 4;
-        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
-            return ERR_INVALID_COMBINATION_KERNEL;
-        }
-
-        const auto thread =
-            current_process->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
-        if (!thread) {
-            return ERR_INVALID_HANDLE;
-        }
-
-        const auto& system = Core::System::GetInstance();
-        const auto& scheduler = system.CurrentScheduler();
-        const auto* const current_thread = scheduler.GetCurrentThread();
-        const bool same_thread = current_thread == thread;
-
-        const u64 prev_ctx_ticks = scheduler.GetLastContextSwitchTicks();
-        u64 out_ticks = 0;
-        if (same_thread && info_sub_id == 0xFFFFFFFFFFFFFFFF) {
-            const u64 thread_ticks = current_thread->GetTotalCPUTimeTicks();
-
-            out_ticks = thread_ticks + (CoreTiming::GetTicks() - prev_ctx_ticks);
-        } else if (same_thread && info_sub_id == system.CurrentCoreIndex()) {
-            out_ticks = CoreTiming::GetTicks() - prev_ctx_ticks;
-        }
-
-        *result = out_ticks;
-        break;
-    }
    default:
        UNIMPLEMENTED();
    }
@@ -635,12 +433,13 @@ static ResultCode SetThreadActivity(Handle handle, u32 unknown) {
 static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
    LOG_DEBUG(Kernel_SVC, "called, context=0x{:08X}, thread=0x{:X}", thread_context, handle);

-    const auto* current_process = Core::CurrentProcess();
-    const SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }

+    const auto* current_process = Core::CurrentProcess();
    if (thread->GetOwnerProcess() != current_process) {
        return ERR_INVALID_HANDLE;
    }
@@ -666,11 +465,10 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {

 /// Gets the priority for the specified thread
 static ResultCode GetThreadPriority(u32* priority, Handle handle) {
-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const SharedPtr<Thread> thread = handle_table.Get<Thread>(handle);
-    if (!thread) {
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    if (!thread)
        return ERR_INVALID_HANDLE;
-    }

    *priority = thread->GetPriority();
    return RESULT_SUCCESS;
@@ -682,18 +480,16 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
        return ERR_INVALID_THREAD_PRIORITY;
    }

-    const auto* const current_process = Core::CurrentProcess();
+    auto& kernel = Core::System::GetInstance().Kernel();
+    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    if (!thread)
+        return ERR_INVALID_HANDLE;

    // Note: The kernel uses the current process's resource limit instead of
    // the one from the thread owner's resource limit.
-    const ResourceLimit& resource_limit = current_process->GetResourceLimit();
+    const ResourceLimit& resource_limit = Core::CurrentProcess()->GetResourceLimit();
    if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
-        return ERR_INVALID_THREAD_PRIORITY;
-    }
-
-    SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
-    if (!thread) {
-        return ERR_INVALID_HANDLE;
+        return ERR_NOT_AUTHORIZED;
    }

    thread->SetPriority(priority);
@@ -714,18 +510,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) {
@@ -733,61 +525,46 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
        return ERR_INVALID_MEMORY_PERMISSIONS;
    }

-    auto* const current_process = Core::CurrentProcess();
-    auto shared_memory = current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
    if (!shared_memory) {
        return ERR_INVALID_HANDLE;
    }

-    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(), 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);

-    auto* const current_process = Core::CurrentProcess();
-    auto shared_memory = current_process->GetHandleTable().Get<SharedMemory>(shared_memory_handle);
-    if (!shared_memory) {
-        return ERR_INVALID_HANDLE;
-    }
-
-    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(), addr);
 }

 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                     Handle process_handle, u64 addr) {
-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    SharedPtr<Process> process = handle_table.Get<Process>(process_handle);
+
+    auto& kernel = Core::System::GetInstance().Kernel();
+    SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
    if (!process) {
        return ERR_INVALID_HANDLE;
    }
    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;
@@ -828,19 +605,20 @@ static void ExitProcess() {
 /// Creates a new thread
 static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, VAddr stack_top,
                               u32 priority, s32 processor_id) {
+    std::string name = fmt::format("thread-{:X}", entry_point);
+
    if (priority > THREADPRIO_LOWEST) {
        return ERR_INVALID_THREAD_PRIORITY;
    }

-    auto* const current_process = Core::CurrentProcess();
-    const ResourceLimit& resource_limit = current_process->GetResourceLimit();
+    const ResourceLimit& resource_limit = Core::CurrentProcess()->GetResourceLimit();
    if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
-        return ERR_INVALID_THREAD_PRIORITY;
+        return ERR_NOT_AUTHORIZED;
    }

    if (processor_id == THREADPROCESSORID_DEFAULT) {
        // Set the target CPU to the one specified in the process' exheader.
-        processor_id = current_process->GetDefaultProcessorID();
+        processor_id = Core::CurrentProcess()->GetDefaultProcessorID();
        ASSERT(processor_id != THREADPROCESSORID_DEFAULT);
    }

@@ -855,13 +633,11 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
        return ERR_INVALID_PROCESSOR_ID;
    }

-    const std::string name = fmt::format("thread-{:X}", entry_point);
    auto& kernel = Core::System::GetInstance().Kernel();
    CASCADE_RESULT(SharedPtr<Thread> thread,
                   Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
-                                  *current_process));
-
-    const auto new_guest_handle = current_process->GetHandleTable().Create(thread);
+                                  *Core::CurrentProcess()));
+    const auto new_guest_handle = kernel.HandleTable().Create(thread);
    if (new_guest_handle.Failed()) {
        return new_guest_handle.Code();
    }
@@ -882,8 +658,8 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 static ResultCode StartThread(Handle thread_handle) {
    LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -930,8 +706,8 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
        "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
        mutex_addr, condition_variable_addr, thread_handle, nano_seconds);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
    ASSERT(thread);

    CASCADE_CODE(Mutex::Release(mutex_addr));
@@ -960,7 +736,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)
@@ -1042,9 +818,9 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
                                               mutex_val | Mutex::MutexHasWaitersFlag));

            // The mutex is already owned by some other thread, make this thread wait on it.
-            const Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
-            const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-            auto owner = handle_table.Get<Thread>(owner_handle);
+            auto& kernel = Core::System::GetInstance().Kernel();
+            Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
+            auto owner = kernel.HandleTable().Get<Thread>(owner_handle);
            ASSERT(owner);
            ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
            thread->InvalidateWakeupCallback();
@@ -1123,16 +899,16 @@ static u64 GetSystemTick() {
 static ResultCode CloseHandle(Handle handle) {
    LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);

-    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    return handle_table.Close(handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    return kernel.HandleTable().Close(handle);
 }

 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
    LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    auto event = handle_table.Get<Event>(handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    auto event = kernel.HandleTable().Get<Event>(handle);

    ASSERT(event != nullptr);

@@ -1151,8 +927,8 @@ static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32
 static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask) {
    LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -1167,8 +943,8 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:16X}, core=0x{:X}", thread_handle,
              mask, core);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    auto& kernel = Core::System::GetInstance().Kernel();
+    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
    if (!thread) {
        return ERR_INVALID_HANDLE;
    }
@@ -1229,7 +1005,7 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
    }

    auto& kernel = Core::System::GetInstance().Kernel();
-    auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+    auto& handle_table = kernel.HandleTable();
    auto shared_mem_handle =
        SharedMemory::Create(kernel, handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
                             local_perms, remote_perms);
@@ -1241,39 +1017,14 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
 static ResultCode ClearEvent(Handle handle) {
    LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);

-    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
-    SharedPtr<Event> evt = handle_table.Get<Event>(handle);
-    if (evt == nullptr) {
+    auto& kernel = Core::System::GetInstance().Kernel();
+    SharedPtr<Event> evt = kernel.HandleTable().Get<Event>(handle);
+    if (evt == nullptr)
        return ERR_INVALID_HANDLE;
-    }
-
    evt->Clear();
    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& handle_table = Core::CurrentProcess()->GetHandleTable();
-    const auto process = handle_table.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();
@@ -1409,7 +1160,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"},
@@ -24,6 +24,37 @@ struct PageInfo {
    u64 flags;
 };

+/// Values accepted by svcGetInfo
+enum class GetInfoType : u64 {
+    // 1.0.0+
+    AllowedCpuIdBitmask = 0,
+    AllowedThreadPrioBitmask = 1,
+    MapRegionBaseAddr = 2,
+    MapRegionSize = 3,
+    HeapRegionBaseAddr = 4,
+    HeapRegionSize = 5,
+    TotalMemoryUsage = 6,
+    TotalHeapUsage = 7,
+    IsCurrentProcessBeingDebugged = 8,
+    ResourceHandleLimit = 9,
+    IdleTickCount = 10,
+    RandomEntropy = 11,
+    PerformanceCounter = 0xF0000002,
+    // 2.0.0+
+    AddressSpaceBaseAddr = 12,
+    AddressSpaceSize = 13,
+    NewMapRegionBaseAddr = 14,
+    NewMapRegionSize = 15,
+    // 3.0.0+
+    IsVirtualAddressMemoryEnabled = 16,
+    PersonalMmHeapUsage = 17,
+    TitleId = 18,
+    // 4.0.0+
+    PrivilegedProcessId = 19,
+    // 5.0.0+
+    UserExceptionContextAddr = 20,
+};
+
 void CallSVC(u32 immediate);

 } // namespace Kernel
@@ -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
@@ -4,9 +4,9 @@

 #include <algorithm>
 #include <cinttypes>
-#include <optional>
 #include <vector>

+#include <boost/optional.hpp>
 #include <boost/range/algorithm_ext/erase.hpp>

 #include "common/assert.h"
@@ -94,10 +94,10 @@ void Thread::CancelWakeupTimer() {
    CoreTiming::UnscheduleEventThreadsafe(kernel.ThreadWakeupCallbackEventType(), callback_handle);
 }

-static std::optional<s32> GetNextProcessorId(u64 mask) {
+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;
            }
@@ -142,19 +142,19 @@ void Thread::ResumeFromWait() {

    status = ThreadStatus::Ready;

-    std::optional<s32> new_processor_id = GetNextProcessorId(affinity_mask);
+    boost::optional<s32> new_processor_id = GetNextProcessorId(affinity_mask);
    if (!new_processor_id) {
        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,10 +183,13 @@ 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,
@@ -230,7 +233,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
    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->scheduler = Core::System::GetInstance().Scheduler(processor_id).get();
    thread->scheduler->AddThread(thread, priority);
    thread->tls_address = thread->owner_process->MarkNextAvailableTLSSlotAsUsed(*thread);

@@ -266,7 +269,7 @@ SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 pri
    SharedPtr<Thread> thread = std::move(thread_res).Unwrap();

    // Register 1 must be a handle to the main thread
-    const Handle guest_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
+    const Handle guest_handle = kernel.HandleTable().Create(thread).Unwrap();
    thread->SetGuestHandle(guest_handle);
    thread->GetContext().cpu_registers[1] = guest_handle;

@@ -369,20 +372,20 @@ void Thread::ChangeCore(u32 core, u64 mask) {
        return;
    }

-    std::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
+    boost::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};

    if (!new_processor_id) {
        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();
 }
@@ -258,14 +258,6 @@ public:
        return last_running_ticks;
    }

-    u64 GetTotalCPUTimeTicks() const {
-        return total_cpu_time_ticks;
-    }
-
-    void UpdateCPUTimeTicks(u64 ticks) {
-        total_cpu_time_ticks += ticks;
-    }
-
    s32 GetProcessorID() const {
        return processor_id;
    }
@@ -386,8 +378,7 @@ private:
    u32 nominal_priority = 0; ///< Nominal thread priority, as set by the emulated application
    u32 current_priority = 0; ///< Current thread priority, can be temporarily changed

-    u64 total_cpu_time_ticks = 0; ///< Total CPU running ticks.
-    u64 last_running_ticks = 0;   ///< CPU tick when thread was last running
+    u64 last_running_ticks = 0; ///< CPU tick when thread was last running

    s32 processor_id = 0;

@@ -119,6 +119,28 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
    return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
 }

+ResultVal<VAddr> VMManager::FindFreeRegion(u32 size) {
+    VAddr base = GetAddressSpaceBaseAddress();
+
+    // Find the first Free VMA.
+    VMAHandle vma_handle = std::find_if(vma_map.begin(), vma_map.end(), [&](const auto& vma) {
+        if (vma.second.type != VMAType::Free)
+            return false;
+
+        VAddr vma_end = vma.second.base + vma.second.size;
+        return vma_end > base && vma_end >= base + size;
+    });
+
+    if (vma_handle == vma_map.end()) {
+        // TODO(Subv): Find the correct error code here.
+        return ResultCode(-1);
+    }
+
+    VAddr target = std::max(base, vma_handle->second.base);
+
+    return MakeResult<VAddr>(target);
+}
+
 ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* memory, u64 size,
                                                            MemoryState state) {
    ASSERT(memory != nullptr);
@@ -143,26 +165,6 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
    return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
 }

-ResultVal<VAddr> VMManager::FindFreeRegion(u64 size) const {
-    // Find the first Free VMA.
-    const VAddr base = GetASLRRegionBaseAddress();
-    const VMAHandle vma_handle = std::find_if(vma_map.begin(), vma_map.end(), [&](const auto& vma) {
-        if (vma.second.type != VMAType::Free)
-            return false;
-
-        const VAddr vma_end = vma.second.base + vma.second.size;
-        return vma_end > base && vma_end >= base + size;
-    });
-
-    if (vma_handle == vma_map.end()) {
-        // TODO(Subv): Find the correct error code here.
-        return ResultCode(-1);
-    }
-
-    const VAddr target = std::max(base, vma_handle->second.base);
-    return MakeResult<VAddr>(target);
-}
-
 ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u64 size,
                                                   MemoryState state,
                                                   Memory::MemoryHookPointer mmio_handler) {
@@ -413,35 +415,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;
@@ -515,38 +512,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;
 }
@@ -147,6 +147,14 @@ public:
    ResultVal<VMAHandle> MapMemoryBlock(VAddr target, std::shared_ptr<std::vector<u8>> block,
                                        std::size_t offset, u64 size, MemoryState state);

+    /**
+     * Finds the first free address that can hold a region of the desired size.
+     *
+     * @param size Size of the desired region.
+     * @returns The found free address.
+     */
+    ResultVal<VAddr> FindFreeRegion(u32 size);
+
    /**
     * Maps an unmanaged host memory pointer at a given address.
     *
@@ -157,14 +165,6 @@ public:
     */
    ResultVal<VMAHandle> MapBackingMemory(VAddr target, u8* memory, u64 size, MemoryState state);

-    /**
-     * Finds the first free address that can hold a region of the desired size.
-     *
-     * @param size Size of the desired region.
-     * @return The found free address.
-     */
-    ResultVal<VAddr> FindFreeRegion(u64 size) const;
-
    /**
     * Maps a memory-mapped IO region at a given address.
     *
@@ -213,18 +213,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;

@@ -326,9 +314,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;

@@ -2,13 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <algorithm>
 #include <array>
-#include "common/common_paths.h"
 #include "common/common_types.h"
-#include "common/file_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
@@ -20,7 +16,6 @@
 #include "core/hle/service/acc/profile_manager.h"

 namespace Service::Account {
-
 // TODO: RE this structure
 struct UserData {
    INSERT_PADDING_WORDS(1);
@@ -32,29 +27,6 @@ struct UserData {
 };
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");

-// Smallest JPEG https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
-// used as a backup should the one on disk not exist
-constexpr u32 backup_jpeg_size = 107;
-constexpr std::array<u8, backup_jpeg_size> backup_jpeg{{
-    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
-    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
-    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
-    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
-    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
-    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
-    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-}};
-
-static std::string GetImagePath(UUID uuid) {
-    return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-           "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
-}
-
-static constexpr u32 SanitizeJPEGSize(std::size_t size) {
-    constexpr std::size_t max_jpeg_image_size = 0x20000;
-    return static_cast<u32>(std::min(size, max_jpeg_image_size));
-}
-
 class IProfile final : public ServiceFramework<IProfile> {
 public:
    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
@@ -101,42 +73,32 @@ private:
    }

    void LoadImage(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called");
-
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        // smallest jpeg https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
+        // TODO(mailwl): load actual profile image from disk, width 256px, max size 0x20000
+        constexpr u32 jpeg_size = 107;
+        static constexpr std::array<u8, jpeg_size> jpeg{
+            0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
+            0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04,
+            0x08, 0x06, 0x06, 0x05, 0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a,
+            0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e, 0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f,
+            0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13, 0x12, 0x10, 0x13, 0x0f, 0x10, 0x10,
+            0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x11, 0x00,
+            0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
+            0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
+        };
+        ctx.WriteBuffer(jpeg);
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-
-        const FileUtil::IOFile image(GetImagePath(user_id), "rb");
-        if (!image.IsOpen()) {
-            LOG_WARNING(Service_ACC,
-                        "Failed to load user provided image! Falling back to built-in backup...");
-            ctx.WriteBuffer(backup_jpeg);
-            rb.Push<u32>(backup_jpeg_size);
-            return;
-        }
-
-        const u32 size = SanitizeJPEGSize(image.GetSize());
-        std::vector<u8> buffer(size);
-        image.ReadBytes(buffer.data(), buffer.size());
-
-        ctx.WriteBuffer(buffer.data(), buffer.size());
-        rb.Push<u32>(size);
+        rb.Push<u32>(jpeg_size);
    }

    void GetImageSize(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called");
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        constexpr u32 jpeg_size = 107;
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-
-        const FileUtil::IOFile image(GetImagePath(user_id), "rb");
-
-        if (!image.IsOpen()) {
-            LOG_WARNING(Service_ACC,
-                        "Failed to load user provided image! Falling back to built-in backup...");
-            rb.Push<u32>(backup_jpeg_size);
-        } else {
-            rb.Push<u32>(SanitizeJPEGSize(image.GetSize()));
-        }
+        rb.Push<u32>(jpeg_size);
    }

    const ProfileManager& profile_manager;
@@ -242,28 +204,6 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
    LOG_DEBUG(Service_ACC, "called");
 }

-void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
-    // A u8 is passed into this function which we can safely ignore. It's to determine if we have
-    // access to use the network or not by the looks of it
-    IPC::ResponseBuilder rb{ctx, 6};
-    if (profile_manager->GetUserCount() != 1) {
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u128>(INVALID_UUID);
-        return;
-    }
-    auto user_list = profile_manager->GetAllUsers();
-    if (user_list.empty()) {
-        rb.Push(ResultCode(-1)); // TODO(ogniK): Find the correct error code
-        rb.PushRaw<u128>(INVALID_UUID);
-        return;
-    }
-
-    // Select the first user we have
-    rb.Push(RESULT_SUCCESS);
-    rb.PushRaw<u128>(profile_manager->GetUser(0)->uuid);
-}
-
 Module::Interface::Interface(std::shared_ptr<Module> module,
                             std::shared_ptr<ProfileManager> profile_manager, const char* name)
    : ServiceFramework(name), module(std::move(module)),
@@ -27,7 +27,6 @@ public:
        void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
        void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);
        void IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx);
-        void TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx);

    protected:
        std::shared_ptr<Module> module;
@@ -17,7 +17,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {5, &ACC_SU::GetProfile, "GetProfile"},
        {6, nullptr, "GetProfileDigest"},
        {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
-        {51, &ACC_SU::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
+        {51, nullptr, "TrySelectUserWithoutInteraction"},
        {60, nullptr, "ListOpenContextStoredUsers"},
        {100, nullptr, "GetUserRegistrationNotifier"},
        {101, nullptr, "GetUserStateChangeNotifier"},
@@ -17,7 +17,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {5, &ACC_U0::GetProfile, "GetProfile"},
        {6, nullptr, "GetProfileDigest"},
        {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
-        {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
+        {51, nullptr, "TrySelectUserWithoutInteraction"},
        {60, nullptr, "ListOpenContextStoredUsers"},
        {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
        {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
@@ -17,7 +17,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {5, &ACC_U1::GetProfile, "GetProfile"},
        {6, nullptr, "GetProfileDigest"},
        {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
-        {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
+        {51, nullptr, "TrySelectUserWithoutInteraction"},
        {60, nullptr, "ListOpenContextStoredUsers"},
        {100, nullptr, "GetUserRegistrationNotifier"},
        {101, nullptr, "GetUserStateChangeNotifier"},
@@ -3,66 +3,41 @@
 // Refer to the license.txt file included.

 #include <random>
-
-#include "common/file_util.h"
+#include <boost/optional.hpp>
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"

 namespace Service::Account {
-
-struct UserRaw {
-    UUID uuid;
-    UUID uuid2;
-    u64 timestamp;
-    ProfileUsername username;
-    INSERT_PADDING_BYTES(0x80);
-};
-static_assert(sizeof(UserRaw) == 0xC8, "UserRaw has incorrect size.");
-
-struct ProfileDataRaw {
-    INSERT_PADDING_BYTES(0x10);
-    std::array<UserRaw, MAX_USERS> users;
-};
-static_assert(sizeof(ProfileDataRaw) == 0x650, "ProfileDataRaw has incorrect size.");
-
 // TODO(ogniK): Get actual error codes
 constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, -1);
 constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, -2);
 constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);

-constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "/system/save/8000000000000010/su/avators/";
-
-UUID UUID::Generate() {
+const UUID& UUID::Generate() {
    std::random_device device;
    std::mt19937 gen(device());
    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    return UUID{distribution(gen), distribution(gen)};
+    uuid[0] = distribution(gen);
+    uuid[1] = distribution(gen);
+    return *this;
 }

 ProfileManager::ProfileManager() {
-    ParseUserSaveFile();
-
-    if (user_count == 0)
-        CreateNewUser(UUID::Generate(), "yuzu");
-
-    auto current = std::clamp<int>(Settings::values.current_user, 0, MAX_USERS - 1);
-    if (UserExistsIndex(current))
-        current = 0;
-
-    OpenUser(*GetUser(current));
+    // TODO(ogniK): Create the default user we have for now until loading/saving users is added
+    auto user_uuid = UUID{1, 0};
+    ASSERT(CreateNewUser(user_uuid, Settings::values.username).IsSuccess());
+    OpenUser(user_uuid);
 }

-ProfileManager::~ProfileManager() {
-    WriteUserSaveFile();
-}
+ProfileManager::~ProfileManager() = default;

 /// After a users creation it needs to be "registered" to the system. AddToProfiles handles the
 /// internal management of the users profiles
-std::optional<std::size_t> ProfileManager::AddToProfiles(const ProfileInfo& profile) {
+boost::optional<std::size_t> ProfileManager::AddToProfiles(const ProfileInfo& user) {
    if (user_count >= MAX_USERS) {
-        return {};
+        return boost::none;
    }
-    profiles[user_count] = profile;
+    profiles[user_count] = user;
    return user_count++;
 }

@@ -81,7 +56,7 @@ bool ProfileManager::RemoveProfileAtIndex(std::size_t index) {

 /// Helper function to register a user to the system
 ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
-    if (!AddToProfiles(user)) {
+    if (AddToProfiles(user) == boost::none) {
        return ERROR_TOO_MANY_USERS;
    }
    return RESULT_SUCCESS;
@@ -126,40 +101,31 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username)
    return CreateNewUser(uuid, username_output);
 }

-std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
-    if (index >= MAX_USERS) {
-        return {};
-    }
-
-    return profiles[index].user_uuid;
-}
-
 /// Returns a users profile index based on their user id.
-std::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
+boost::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
    if (!uuid) {
-        return {};
+        return boost::none;
    }
-
-    const auto iter = std::find_if(profiles.begin(), profiles.end(),
-                                   [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
+    auto iter = std::find_if(profiles.begin(), profiles.end(),
+                             [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
    if (iter == profiles.end()) {
-        return {};
+        return boost::none;
    }
-
    return static_cast<std::size_t>(std::distance(profiles.begin(), iter));
 }

 /// Returns a users profile index based on their profile
-std::optional<std::size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
+boost::optional<std::size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
    return GetUserIndex(user.user_uuid);
 }

 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
-bool ProfileManager::GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const {
-    if (!index || index >= MAX_USERS) {
+bool ProfileManager::GetProfileBase(boost::optional<std::size_t> index,
+                                    ProfileBase& profile) const {
+    if (index == boost::none || index >= MAX_USERS) {
        return false;
    }
-    const auto& prof_info = profiles[*index];
+    const auto& prof_info = profiles[index.get()];
    profile.user_uuid = prof_info.user_uuid;
    profile.username = prof_info.username;
    profile.timestamp = prof_info.creation_time;
@@ -168,7 +134,7 @@ bool ProfileManager::GetProfileBase(std::optional<std::size_t> index, ProfileBas

 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
 bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
-    const auto idx = GetUserIndex(uuid);
+    auto idx = GetUserIndex(uuid);
    return GetProfileBase(idx, profile);
 }

@@ -195,34 +161,26 @@ std::size_t ProfileManager::GetOpenUserCount() const {

 /// Checks if a user id exists in our profile manager
 bool ProfileManager::UserExists(UUID uuid) const {
-    return GetUserIndex(uuid).has_value();
-}
-
-bool ProfileManager::UserExistsIndex(std::size_t index) const {
-    if (index >= MAX_USERS)
-        return false;
-    return profiles[index].user_uuid.uuid != INVALID_UUID;
+    return (GetUserIndex(uuid) != boost::none);
 }

 /// Opens a specific user
 void ProfileManager::OpenUser(UUID uuid) {
-    const auto idx = GetUserIndex(uuid);
-    if (!idx) {
+    auto idx = GetUserIndex(uuid);
+    if (idx == boost::none) {
        return;
    }
-
-    profiles[*idx].is_open = true;
+    profiles[idx.get()].is_open = true;
    last_opened_user = uuid;
 }

 /// Closes a specific user
 void ProfileManager::CloseUser(UUID uuid) {
-    const auto idx = GetUserIndex(uuid);
-    if (!idx) {
+    auto idx = GetUserIndex(uuid);
+    if (idx == boost::none) {
        return;
    }
-
-    profiles[*idx].is_open = false;
+    profiles[idx.get()].is_open = false;
 }

 /// Gets all valid user ids on the system
@@ -252,10 +210,10 @@ UUID ProfileManager::GetLastOpenedUser() const {
 }

 /// Return the users profile base and the unknown arbitary data.
-bool ProfileManager::GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
+bool ProfileManager::GetProfileBaseAndData(boost::optional<std::size_t> index, ProfileBase& profile,
                                           ProfileData& data) const {
    if (GetProfileBase(index, profile)) {
-        data = profiles[*index].data;
+        data = profiles[index.get()].data;
        return true;
    }
    return false;
@@ -264,7 +222,7 @@ bool ProfileManager::GetProfileBaseAndData(std::optional<std::size_t> index, Pro
 /// Return the users profile base and the unknown arbitary data.
 bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
                                           ProfileData& data) const {
-    const auto idx = GetUserIndex(uuid);
+    auto idx = GetUserIndex(uuid);
    return GetProfileBaseAndData(idx, profile, data);
 }

@@ -281,96 +239,4 @@ bool ProfileManager::CanSystemRegisterUser() const {
    // emulate qlaunch. Update this to dynamically change.
 }

-bool ProfileManager::RemoveUser(UUID uuid) {
-    const auto index = GetUserIndex(uuid);
-    if (!index) {
-        return false;
-    }
-
-    profiles[*index] = ProfileInfo{};
-    std::stable_partition(profiles.begin(), profiles.end(),
-                          [](const ProfileInfo& profile) { return profile.user_uuid; });
-    return true;
-}
-
-bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
-    const auto index = GetUserIndex(uuid);
-    if (!index || profile_new.user_uuid == UUID(INVALID_UUID)) {
-        return false;
-    }
-
-    auto& profile = profiles[*index];
-    profile.user_uuid = profile_new.user_uuid;
-    profile.username = profile_new.username;
-    profile.creation_time = profile_new.timestamp;
-
-    return true;
-}
-
-void ProfileManager::ParseUserSaveFile() {
-    FileUtil::IOFile save(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                              ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat",
-                          "rb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
-                                 "user 'yuzu' with random UUID.");
-        return;
-    }
-
-    ProfileDataRaw data;
-    if (save.ReadBytes(&data, sizeof(ProfileDataRaw)) != sizeof(ProfileDataRaw)) {
-        LOG_WARNING(Service_ACC, "profiles.dat is smaller than expected... Generating new user "
-                                 "'yuzu' with random UUID.");
-        return;
-    }
-
-    for (std::size_t i = 0; i < MAX_USERS; ++i) {
-        const auto& user = data.users[i];
-
-        if (user.uuid != UUID(INVALID_UUID))
-            AddUser({user.uuid, user.username, user.timestamp, {}, false});
-    }
-
-    std::stable_partition(profiles.begin(), profiles.end(),
-                          [](const ProfileInfo& profile) { return profile.user_uuid; });
-}
-
-void ProfileManager::WriteUserSaveFile() {
-    ProfileDataRaw raw{};
-
-    for (std::size_t i = 0; i < MAX_USERS; ++i) {
-        raw.users[i].username = profiles[i].username;
-        raw.users[i].uuid2 = profiles[i].user_uuid;
-        raw.users[i].uuid = profiles[i].user_uuid;
-        raw.users[i].timestamp = profiles[i].creation_time;
-    }
-
-    const auto raw_path =
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010";
-    if (FileUtil::Exists(raw_path) && !FileUtil::IsDirectory(raw_path))
-        FileUtil::Delete(raw_path);
-
-    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                      ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat";
-
-    if (!FileUtil::CreateFullPath(path)) {
-        LOG_WARNING(Service_ACC, "Failed to create full path of profiles.dat. Create the directory "
-                                 "nand/system/save/8000000000000010/su/avators to mitigate this "
-                                 "issue.");
-        return;
-    }
-
-    FileUtil::IOFile save(path, "wb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_ACC, "Failed to write save data to file... No changes to user data "
-                                 "made in current session will be saved.");
-        return;
-    }
-
-    save.Resize(sizeof(ProfileDataRaw));
-    save.WriteBytes(&raw, sizeof(ProfileDataRaw));
-}
-
 }; // namespace Service::Account
@@ -5,8 +5,8 @@
 #pragma once

 #include <array>
-#include <optional>

+#include "boost/optional.hpp"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/result.h"
@@ -36,7 +36,7 @@ struct UUID {
    }

    // TODO(ogniK): Properly generate uuids based on RFC-4122
-    static UUID Generate();
+    const UUID& Generate();

    // Set the UUID to {0,0} to be considered an invalid user
    void Invalidate() {
@@ -45,20 +45,10 @@ struct UUID {
    std::string Format() const {
        return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
    }
-
-    std::string FormatSwitch() const {
-        std::array<u8, 16> s{};
-        std::memcpy(s.data(), uuid.data(), sizeof(u128));
-        return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
-                           ":02x}{:02x}{:02x}{:02x}{:02x}",
-                           s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
-                           s[12], s[13], s[14], s[15]);
-    }
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");

-constexpr std::size_t profile_username_size = 32;
-using ProfileUsername = std::array<u8, profile_username_size>;
+using ProfileUsername = std::array<u8, 0x20>;
 using ProfileData = std::array<u8, MAX_DATA>;
 using UserIDArray = std::array<UUID, MAX_USERS>;

@@ -91,19 +81,18 @@ static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase is an invalid size");
 /// objects
 class ProfileManager {
 public:
-    ProfileManager();
+    ProfileManager(); // TODO(ogniK): Load from system save
    ~ProfileManager();

    ResultCode AddUser(const ProfileInfo& user);
    ResultCode CreateNewUser(UUID uuid, const ProfileUsername& username);
    ResultCode CreateNewUser(UUID uuid, const std::string& username);
-    std::optional<UUID> GetUser(std::size_t index) const;
-    std::optional<std::size_t> GetUserIndex(const UUID& uuid) const;
-    std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
-    bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
+    boost::optional<std::size_t> GetUserIndex(const UUID& uuid) const;
+    boost::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
+    bool GetProfileBase(boost::optional<std::size_t> index, ProfileBase& profile) const;
    bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
    bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
-    bool GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
+    bool GetProfileBaseAndData(boost::optional<std::size_t> index, ProfileBase& profile,
                               ProfileData& data) const;
    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile, ProfileData& data) const;
    bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
@@ -111,7 +100,6 @@ public:
    std::size_t GetUserCount() const;
    std::size_t GetOpenUserCount() const;
    bool UserExists(UUID uuid) const;
-    bool UserExistsIndex(std::size_t index) const;
    void OpenUser(UUID uuid);
    void CloseUser(UUID uuid);
    UserIDArray GetOpenUsers() const;
@@ -120,17 +108,11 @@ public:

    bool CanSystemRegisterUser() const;

-    bool RemoveUser(UUID uuid);
-    bool SetProfileBase(UUID uuid, const ProfileBase& profile_new);
-
 private:
-    void ParseUserSaveFile();
-    void WriteUserSaveFile();
-    std::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
-    bool RemoveProfileAtIndex(std::size_t index);
-
    std::array<ProfileInfo, MAX_USERS> profiles{};
    std::size_t user_count = 0;
+    boost::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
+    bool RemoveProfileAtIndex(std::size_t index);
    UUID last_opened_user{INVALID_UUID};
 };

@@ -4,20 +4,17 @@

 #include <array>
 #include <cinttypes>
-#include <cstring>
 #include <stack>
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
 #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"
@@ -28,29 +25,14 @@

 namespace Service::AM {

-constexpr u32 POP_LAUNCH_PARAMETER_MAGIC = 0xC79497CA;
-
-struct LaunchParameters {
-    u32_le magic;
-    u32_le is_account_selected;
-    u128 current_user;
-    INSERT_PADDING_BYTES(0x70);
-};
-static_assert(sizeof(LaunchParameters) == 0x88);
-
 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);
 }

@@ -105,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"},
@@ -136,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);
 }

@@ -151,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"},
@@ -160,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"},
@@ -187,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();
@@ -339,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"},
@@ -364,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();
@@ -461,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);
    }

@@ -521,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);
    }

@@ -547,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"},
@@ -568,8 +532,6 @@ public:
            {150, nullptr, "RequestForAppletToGetForeground"},
            {160, nullptr, "GetIndirectLayerConsumerHandle"},
        };
-        // clang-format on
-
        RegisterHandlers(functions);

        auto& kernel = Core::System::GetInstance().Kernel();
@@ -662,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"},
@@ -676,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"},
@@ -702,57 +664,26 @@ 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) {
-    LaunchParameters params{};
+    constexpr std::array<u8, 0x88> data{{
+        0xca, 0x97, 0x94, 0xc7, // Magic
+        1,    0,    0,    0,    // IsAccountSelected (bool)
+        1,    0,    0,    0,    // User Id (word 0)
+        0,    0,    0,    0,    // User Id (word 1)
+        0,    0,    0,    0,    // User Id (word 2)
+        0,    0,    0,    0     // User Id (word 3)
+    }};

-    params.magic = POP_LAUNCH_PARAMETER_MAGIC;
-    params.is_account_selected = 1;
-
-    Account::ProfileManager profile_manager{};
-    const auto uuid = profile_manager.GetUser(Settings::values.current_user);
-    ASSERT(uuid);
-    params.current_user = uuid->uuid;
+    std::vector<u8> buffer(data.begin(), data.end());

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};

    rb.Push(RESULT_SUCCESS);
-
-    std::vector<u8> buffer(sizeof(LaunchParameters));
-    std::memcpy(buffer.data(), &params, buffer.size());
-
    rb.PushIpcInterface<AM::IStorage>(buffer);

    LOG_DEBUG(Service_AM, "called");
@@ -845,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"},
@@ -858,10 +787,7 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
        {21, nullptr, "GetPopFromGeneralChannelEvent"},
        {30, nullptr, "GetHomeButtonWriterLockAccessor"},
        {31, nullptr, "GetWriterLockAccessorEx"},
-        {100, nullptr, "PopRequestLaunchApplicationForDebug"},
    };
-    // clang-format on
-
    RegisterHandlers(functions);
 }

@@ -874,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"},
@@ -888,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);
 }

@@ -912,7 +832,6 @@ IApplicationCreator::~IApplicationCreator() = default;

 IProcessWindingController::IProcessWindingController()
    : ServiceFramework("IProcessWindingController") {
-    // clang-format off
    static const FunctionInfo functions[] = {
        {0, nullptr, "GetLaunchReason"},
        {11, nullptr, "OpenCallingLibraryApplet"},
@@ -923,8 +842,6 @@ IProcessWindingController::IProcessWindingController()
        {40, nullptr, "ReserveToStartAndWaitAndUnwindThis"},
        {41, nullptr, "ReserveToStartAndWait"},
    };
-    // clang-format on
-
    RegisterHandlers(functions);
 }

@@ -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> {
@@ -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);
 }

@@ -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);
    }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Subv	d356a8eceb	Services/LDR: Implemented the ldr:ro LoadNRO andLoadNRR service functions. The implementation was based on Atmosphere's implementation of the ldr:ro service. This is an incomplete commit, the error condition checks are missing.	2018-10-10 19:10:04 -05:00
Subv	9ff787bf61	Kernel/Memory: Added a function to first a suitable guest address at which to allocate a region of a given size.	2018-10-10 19:10:03 -05:00
Subv	5fb8854a11	Kernel/Memory: Allow specifying a MemoryState when mirroring memory. Not all mirrored memory should have the Mapped memory state.	2018-10-10 19:10:02 -05:00