Update configure_input.ui

oopsie...

.travis.yml

@@ -20,7 +20,6 @@ matrix:
       install: "./.travis/linux/deps.sh"
       script: "./.travis/linux/build.sh"
       after_success: "./.travis/linux/upload.sh"
-      cache: ccache
     - os: osx
       env: NAME="macos build"
       sudo: false
@@ -28,7 +27,6 @@ matrix:
       install: "./.travis/macos/deps.sh"
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"
-      cache: ccache
 
 deploy:
   provider: releases
@@ -44,3 +42,7 @@ notifications:
   webhooks:
     urls:
       - https://api.yuzu-emu.org/code/travis/notify
+
+cache:
+  directories:
+    - $HOME/.ccache

.travis/common/travis-ci.env

@@ -1,12 +0,0 @@
-# List of environment variables to be shared with Docker containers
-CI
-TRAVIS
-CONTINUOUS_INTEGRATION
-TRAVIS_BRANCH
-TRAVIS_BUILD_ID
-TRAVIS_BUILD_NUMBER
-TRAVIS_COMMIT
-TRAVIS_JOB_ID
-TRAVIS_JOB_NUMBER
-TRAVIS_REPO_SLUG
-TRAVIS_TAG

.travis/linux/build.sh

@@ -1,4 +1,3 @@
 #!/bin/bash -ex
 
-mkdir -p "$HOME/.ccache"
-docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e CCACHE_DIR=/ccache -v $HOME/.ccache:/ccache -v $(pwd):/yuzu ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh

.travis/linux/docker.sh

@@ -5,8 +5,14 @@ apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev
 
 cd /yuzu
 
+export PATH=/usr/lib/ccache:$PATH
+ln -sf /usr/bin/ccache /usr/lib/ccache/cc
+ln -sf /usr/bin/ccache /usr/lib/ccache/c++
 mkdir build && cd build
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -G Ninja
+ccache --show-stats > ccache_before
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
 ninja
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

.travis/macos/build.sh

@@ -5,11 +5,14 @@ set -o pipefail
 export MACOSX_DEPLOYMENT_TARGET=10.12
 export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
-export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 mkdir build && cd build
+export PATH=/usr/local/opt/ccache/libexec:$PATH
+ccache --show-stats > ccache_before
 cmake --version
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
 make -j4
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

CMakeLists.txt

@@ -41,19 +41,6 @@ function(check_submodules_present)
 endfunction()
 check_submodules_present()
 
-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 ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    message(STATUS "Downloading compatibility list for yuzu...")
-    file(DOWNLOAD
-        https://api.yuzu-emu.org/gamedb/
-        "${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
-endif()
-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
 # =======================================================================
 

appveyor.yml

@@ -41,9 +41,9 @@ before_build:
   - ps: |
         if ($env:BUILD_TYPE -eq 'msvc') {
           # redirect stderr and change the exit code to prevent powershell from cancelling the build if cmake prints a warning
-          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON .. 2>&1 && exit 0'
+          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 .. 2>&1 && exit 0'
         } else {
-          C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON .. 2>&1"
+          C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release .. 2>&1"
         }
   - cd ..
 
@@ -162,6 +162,10 @@ artifacts:
   - path: $(BUILD_ZIP)
     name: build
     type: zip
+  - path: $(BUILD_SYMBOLS)
+    name: debugsymbols
+  - path: $(BUILD_UPDATE)
+    name: update
 
 deploy:
   provider: GitHub

dist/compatibility_list/compatibility_list.qrc

@@ -1,5 +0,0 @@
-<RCC>
-  <qresource prefix="compatibility_list">
-      <file>compatibility_list.json</file>
-  </qresource>
-</RCC>

externals/CMakeLists.txt

@@ -43,9 +43,6 @@ target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)
 
-# Open Source Archives
-add_subdirectory(open_source_archives EXCLUDE_FROM_ALL)
-
 # Unicorn
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)

externals/open_source_archives/CMakeLists.txt

@@ -1,16 +0,0 @@
-add_library(open_source_archives
-    src/FontChineseSimplified.cpp
-    src/FontChineseTraditional.cpp
-    src/FontExtendedChineseSimplified.cpp
-    src/FontKorean.cpp
-    src/FontNintendoExtended.cpp
-    src/FontStandard.cpp
-    include/FontChineseSimplified.h
-    include/FontChineseTraditional.h
-    include/FontExtendedChineseSimplified.h
-    include/FontKorean.h
-    include/FontNintendoExtended.h
-    include/FontStandard.h
-)
-
-target_include_directories(open_source_archives PUBLIC include)

externals/open_source_archives/Readme.md

@@ -1,4 +0,0 @@
-These files were generated by https://github.com/FearlessTobi/yuzu_system_archives at git commit 0a24b0c9f38d71fb2c4bba5645a39029e539a5ec. To generate the files use the run.sh inside that repository.  
-
-The follwing system archives are currently included:
- - JPN/EUR/USA System Font

externals/open_source_archives/include/FontChineseSimplified.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 217276> FontChineseSimplified;
-

externals/open_source_archives/include/FontChineseTraditional.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 222236> FontChineseTraditional;
-

externals/open_source_archives/include/FontExtendedChineseSimplified.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 293516> FontExtendedChineseSimplified;
-

externals/open_source_archives/include/FontKorean.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 217276> FontKorean;
-

externals/open_source_archives/include/FontNintendoExtended.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 172064> FontNintendoExtended;
-

externals/open_source_archives/include/FontStandard.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 217276> FontStandard;
-

src/audio_core/audio_renderer.cpp

@@ -17,10 +17,10 @@ AudioRenderer::AudioRenderer(AudioRendererParameter params,
                              Kernel::SharedPtr<Kernel::Event> buffer_event)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count) {
 
-    audio_out = std::make_unique<AudioCore::AudioOut>();
-    stream = audio_out->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
-                                   [=]() { buffer_event->Signal(); });
-    audio_out->StartStream(stream);
+    audio_core = std::make_unique<AudioCore::AudioOut>();
+    stream = audio_core->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
+                                    [=]() { buffer_event->Signal(); });
+    audio_core->StartStream(stream);
 
     QueueMixedBuffer(0);
     QueueMixedBuffer(1);
@@ -236,11 +236,11 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
             }
         }
     }
-    audio_out->QueueBuffer(stream, tag, std::move(buffer));
+    audio_core->QueueBuffer(stream, tag, std::move(buffer));
 }
 
 void AudioRenderer::ReleaseAndQueueBuffers() {
-    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream, 2)};
+    const auto released_buffers{audio_core->GetTagsAndReleaseBuffers(stream, 2)};
     for (const auto& tag : released_buffers) {
         QueueMixedBuffer(tag);
     }

src/audio_core/audio_renderer.h

@@ -204,7 +204,7 @@ private:
     AudioRendererParameter worker_params;
     Kernel::SharedPtr<Kernel::Event> buffer_event;
     std::vector<VoiceState> voices;
-    std::unique_ptr<AudioCore::AudioOut> audio_out;
+    std::unique_ptr<AudioCore::AudioOut> audio_core;
     AudioCore::StreamPtr stream;
 };
 

src/audio_core/stream.cpp

@@ -10,7 +10,6 @@
 #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"
@@ -95,10 +94,7 @@ 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();

src/common/CMakeLists.txt

@@ -1,16 +1,13 @@
 # Generate cpp with Git revision from template
-# Also if this is a CI build, add the build name (ie: Nightly, Canary) to the scm_rev file as well
+# Also if this is a CI build, add the build name (ie: Nightly, Bleeding Edge) to the scm_rev file as well
 set(REPO_NAME "")
-set(BUILD_VERSION "0")
 if ($ENV{CI})
   if ($ENV{TRAVIS})
     set(BUILD_REPOSITORY $ENV{TRAVIS_REPO_SLUG})
-    set(BUILD_TAG $ENV{TRAVIS_TAG})
   elseif($ENV{APPVEYOR})
     set(BUILD_REPOSITORY $ENV{APPVEYOR_REPO_NAME})
-    set(BUILD_TAG $ENV{APPVEYOR_REPO_TAG_NAME})
   endif()
-  # regex capture the string nightly or canary into CMAKE_MATCH_1
+  # regex capture the string nightly or bleeding-edge into CMAKE_MATCH_1
   string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
   if (${CMAKE_MATCH_COUNT} GREATER 0)
     # capitalize the first letter of each word in the repo name.
@@ -19,21 +16,10 @@ if ($ENV{CI})
       string(SUBSTRING ${WORD} 0 1 FIRST_LETTER)
       string(SUBSTRING ${WORD} 1 -1 REMAINDER)
       string(TOUPPER ${FIRST_LETTER} FIRST_LETTER)
-      set(REPO_NAME "${REPO_NAME}${FIRST_LETTER}${REMAINDER}")
+      # this leaves a trailing space on the last word, but we actually want that
+      # because of how it's styled in the title bar.
+      set(REPO_NAME "${REPO_NAME}${FIRST_LETTER}${REMAINDER} ")
     endforeach()
-    if (BUILD_TAG)
-      string(REGEX MATCH "${CMAKE_MATCH_1}-([0-9]+)" OUTVAR ${BUILD_TAG})
-      if (${CMAKE_MATCH_COUNT} GREATER 0)
-        set(BUILD_VERSION ${CMAKE_MATCH_1})
-      endif()
-      if (BUILD_VERSION)
-        # This leaves a trailing space on the last word, but we actually want that
-        # because of how it's styled in the title bar.
-        set(BUILD_FULLNAME "${REPO_NAME} #${BUILD_VERSION} ")
-      else()
-        set(BUILD_FULLNAME "")
-      endif()
-    endif()
   endif()
 endif()
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in" "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp" @ONLY)

src/common/file_util.cpp

@@ -764,7 +764,7 @@ size_t ReadFileToString(bool text_file, const char* filename, std::string& str)
     IOFile file(filename, text_file ? "r" : "rb");
 
     if (!file.IsOpen())
-        return 0;
+        return false;
 
     str.resize(static_cast<u32>(file.GetSize()));
     return file.ReadArray(&str[0], str.size());

src/common/hex_util.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/hex_util.h"
-#include "common/logging/log.h"
 
 namespace Common {
 
@@ -14,29 +13,18 @@ u8 ToHexNibble(char c1) {
         return c1 - 87;
     if (c1 >= 48 && c1 <= 57)
         return c1 - 48;
-    LOG_ERROR(Common, "Invalid hex digit: 0x{:02X}", c1);
-    return 0;
+    throw std::logic_error("Invalid hex digit");
 }
 
 std::array<u8, 16> operator""_array16(const char* str, size_t len) {
-    if (len != 32) {
-        LOG_ERROR(Common,
-                  "Attempting to parse string to array that is not of correct size (expected=32, "
-                  "actual={}).",
-                  len);
-        return {};
-    }
+    if (len != 32)
+        throw std::logic_error("Not of correct size.");
     return HexStringToArray<16>(str);
 }
 
 std::array<u8, 32> operator""_array32(const char* str, size_t len) {
-    if (len != 64) {
-        LOG_ERROR(Common,
-                  "Attempting to parse string to array that is not of correct size (expected=64, "
-                  "actual={}).",
-                  len);
-        return {};
-    }
+    if (len != 64)
+        throw std::logic_error("Not of correct size.");
     return HexStringToArray<32>(str);
 }
 

src/common/logging/filter.h

@@ -19,7 +19,7 @@ namespace Log {
 class Filter {
 public:
     /// Initializes the filter with all classes having `default_level` as the minimum level.
-    explicit Filter(Level default_level = Level::Info);
+    Filter(Level default_level = Level::Info);
 
     /// Resets the filter so that all classes have `level` as the minimum displayed level.
     void ResetAll(Level level);
@@ -49,6 +49,6 @@ public:
     bool IsDebug() const;
 
 private:
-    std::array<Level, static_cast<size_t>(Class::Count)> class_levels;
+    std::array<Level, (size_t)Class::Count> class_levels;
 };
 } // namespace Log

src/common/logging/log.h

@@ -12,14 +12,14 @@ namespace Log {
 /// Specifies the severity or level of detail of the log message.
 enum class Level : u8 {
     Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
-              ///< pollute logs.
+              ///  pollute logs.
     Debug,    ///< Less detailed debugging information.
     Info,     ///< Status information from important points during execution.
     Warning,  ///< Minor or potential problems found during execution of a task.
     Error,    ///< Major problems found during execution of a task that prevent it from being
-              ///< completed.
-    Critical, ///< Major problems during execution that threaten the stability of the entire
-              ///< application.
+              ///  completed.
+    Critical, ///< Major problems during execution that threathen the stability of the entire
+              ///  application.
 
     Count ///< Total number of logging levels
 };
@@ -49,7 +49,7 @@ enum class Class : ClassType {
     Kernel,            ///< The HLE implementation of the CTR kernel
     Kernel_SVC,        ///< Kernel system calls
     Service,           ///< HLE implementation of system services. Each major service
-                       ///< should have its own subclass.
+                       ///  should have its own subclass.
     Service_ACC,       ///< The ACC (Accounts) service
     Service_AM,        ///< The AM (Applet manager) service
     Service_AOC,       ///< The AOC (AddOn Content) service

src/common/logging/text_formatter.cpp

@@ -42,7 +42,7 @@ void PrintColoredMessage(const Entry& entry) {
         return;
     }
 
-    CONSOLE_SCREEN_BUFFER_INFO original_info = {};
+    CONSOLE_SCREEN_BUFFER_INFO original_info = {0};
     GetConsoleScreenBufferInfo(console_handle, &original_info);
 
     WORD color = 0;

src/common/logging/text_formatter.h

@@ -15,6 +15,6 @@ struct Entry;
 std::string FormatLogMessage(const Entry& entry);
 /// Formats and prints a log entry to stderr.
 void PrintMessage(const Entry& entry);
-/// Prints the same message as `PrintMessage`, but colored according to the severity level.
+/// Prints the same message as `PrintMessage`, but colored acoording to the severity level.
 void PrintColoredMessage(const Entry& entry);
 } // namespace Log

src/common/scm_rev.cpp.in

@@ -9,8 +9,6 @@
 #define GIT_DESC     "@GIT_DESC@"
 #define BUILD_NAME   "@REPO_NAME@"
 #define BUILD_DATE   "@BUILD_DATE@"
-#define BUILD_FULLNAME "@BUILD_FULLNAME@"
-#define BUILD_VERSION "@BUILD_VERSION@"
 
 namespace Common {
 
@@ -19,8 +17,6 @@ const char g_scm_branch[]   = GIT_BRANCH;
 const char g_scm_desc[]     = GIT_DESC;
 const char g_build_name[]   = BUILD_NAME;
 const char g_build_date[]   = BUILD_DATE;
-const char g_build_fullname[] = BUILD_FULLNAME;
-const char g_build_version[]  = BUILD_VERSION;
 
 } // namespace
 

src/common/scm_rev.h

@@ -11,7 +11,5 @@ extern const char g_scm_branch[];
 extern const char g_scm_desc[];
 extern const char g_build_name[];
 extern const char g_build_date[];
-extern const char g_build_fullname[];
-extern const char g_build_version[];
 
 } // namespace Common

src/core/CMakeLists.txt

@@ -20,8 +20,6 @@ add_library(core STATIC
     crypto/key_manager.h
     crypto/ctr_encryption_layer.cpp
     crypto/ctr_encryption_layer.h
-    crypto/xts_encryption_layer.cpp
-    crypto/xts_encryption_layer.h
     file_sys/bis_factory.cpp
     file_sys/bis_factory.h
     file_sys/card_image.cpp
@@ -35,12 +33,8 @@ add_library(core STATIC
     file_sys/mode.h
     file_sys/nca_metadata.cpp
     file_sys/nca_metadata.h
-    file_sys/nca_patch.cpp
-    file_sys/nca_patch.h
     file_sys/partition_filesystem.cpp
     file_sys/partition_filesystem.h
-    file_sys/patch_manager.cpp
-    file_sys/patch_manager.h
     file_sys/program_metadata.cpp
     file_sys/program_metadata.h
     file_sys/registered_cache.cpp
@@ -53,8 +47,6 @@ add_library(core STATIC
     file_sys/savedata_factory.h
     file_sys/sdmc_factory.cpp
     file_sys/sdmc_factory.h
-    file_sys/submission_package.cpp
-    file_sys/submission_package.h
     file_sys/vfs.cpp
     file_sys/vfs.h
     file_sys/vfs_concat.cpp
@@ -65,8 +57,6 @@ add_library(core STATIC
     file_sys/vfs_real.h
     file_sys/vfs_vector.cpp
     file_sys/vfs_vector.h
-    file_sys/xts_archive.cpp
-    file_sys/xts_archive.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
@@ -357,16 +347,12 @@ add_library(core STATIC
     loader/linker.h
     loader/loader.cpp
     loader/loader.h
-    loader/nax.cpp
-    loader/nax.h
     loader/nca.cpp
     loader/nca.h
     loader/nro.cpp
     loader/nro.h
     loader/nso.cpp
     loader/nso.h
-    loader/nsp.cpp
-    loader/nsp.h
     loader/xci.cpp
     loader/xci.h
     memory.cpp
@@ -388,7 +374,7 @@ add_library(core STATIC
 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)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn)
 
 if (ARCHITECTURE_x86_64)
     target_sources(core PRIVATE

src/core/arm/arm_interface.h

@@ -8,8 +8,6 @@
 #include "common/common_types.h"
 #include "core/hle/kernel/vm_manager.h"
 
-namespace Core {
-
 /// Generic ARM11 CPU interface
 class ARM_Interface : NonCopyable {
 public:
@@ -124,5 +122,3 @@ public:
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
 };
-
-} // namespace Core

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -7,17 +7,13 @@
 #include <dynarmic/A64/a64.h>
 #include <dynarmic/A64/config.h>
 #include "common/logging/log.h"
-#include "common/microprofile.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 
-namespace Core {
-
 using Vector = Dynarmic::A64::Vector;
 
 class ARM_Dynarmic_Callbacks : public Dynarmic::A64::UserCallbacks {
@@ -144,10 +140,7 @@ std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 
-MICROPROFILE_DEFINE(ARM_Jit_Dynarmic, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));
-
 void ARM_Dynarmic::Run() {
-    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic);
     ASSERT(Memory::GetCurrentPageTable() == current_page_table);
 
     jit->Run();
@@ -307,5 +300,3 @@ bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, VAddr vaddr,
         Memory::Write64(vaddr, value[1]);
     });
 }
-
-} // namespace Core

src/core/arm/dynarmic/arm_dynarmic.h

@@ -12,8 +12,6 @@
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
-namespace Core {
-
 class ARM_Dynarmic_Callbacks;
 class DynarmicExclusiveMonitor;
 
@@ -83,5 +81,3 @@ private:
     friend class ARM_Dynarmic;
     Dynarmic::A64::ExclusiveMonitor monitor;
 };
-
-} // namespace Core

src/core/arm/exclusive_monitor.cpp

@@ -4,8 +4,4 @@
 
 #include "core/arm/exclusive_monitor.h"
 
-namespace Core {
-
 ExclusiveMonitor::~ExclusiveMonitor() = default;
-
-} // namespace Core

src/core/arm/exclusive_monitor.h

@@ -6,8 +6,6 @@
 
 #include "common/common_types.h"
 
-namespace Core {
-
 class ExclusiveMonitor {
 public:
     virtual ~ExclusiveMonitor();
@@ -21,5 +19,3 @@ public:
     virtual bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) = 0;
     virtual bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) = 0;
 };
-
-} // namespace Core

src/core/arm/unicorn/arm_unicorn.cpp

@@ -11,8 +11,6 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/svc.h"
 
-namespace Core {
-
 // Load Unicorn DLL once on Windows using RAII
 #ifdef _MSC_VER
 #include <unicorn_dynload.h>
@@ -193,10 +191,10 @@ void ARM_Unicorn::Step() {
     ExecuteInstructions(1);
 }
 
-MICROPROFILE_DEFINE(ARM_Jit_Unicorn, "ARM JIT", "Unicorn", MP_RGB(255, 64, 64));
+MICROPROFILE_DEFINE(ARM_Jit, "ARM JIT", "ARM JIT", MP_RGB(255, 64, 64));
 
 void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
-    MICROPROFILE_SCOPE(ARM_Jit_Unicorn);
+    MICROPROFILE_SCOPE(ARM_Jit);
     CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
     CoreTiming::AddTicks(num_instructions);
     if (GDBStub::IsServerEnabled()) {
@@ -213,7 +211,7 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
     }
 }
 
-void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
+void ARM_Unicorn::SaveContext(ARM_Interface::ThreadContext& ctx) {
     int uregs[32];
     void* tregs[32];
 
@@ -240,7 +238,7 @@ void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
     CHECKED(uc_reg_read_batch(uc, uregs, tregs, 32));
 }
 
-void ARM_Unicorn::LoadContext(const ThreadContext& ctx) {
+void ARM_Unicorn::LoadContext(const ARM_Interface::ThreadContext& ctx) {
     int uregs[32];
     void* tregs[32];
 
@@ -279,5 +277,3 @@ void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
     last_bkpt = bkpt;
     last_bkpt_hit = true;
 }
-
-} // namespace Core

src/core/arm/unicorn/arm_unicorn.h

@@ -9,8 +9,6 @@
 #include "core/arm/arm_interface.h"
 #include "core/gdbstub/gdbstub.h"
 
-namespace Core {
-
 class ARM_Unicorn final : public ARM_Interface {
 public:
     ARM_Unicorn();
@@ -48,5 +46,3 @@ private:
     GDBStub::BreakpointAddress last_bkpt{};
     bool last_bkpt_hit;
 };
-
-} // namespace Core

src/core/core.cpp

@@ -2,35 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
-#include <map>
 #include <memory>
-#include <thread>
 #include <utility>
-
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
-#include "core/file_sys/mode.h"
-#include "core/file_sys/vfs_concat.h"
-#include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/service.h"
+#include "core/hle/service/sm/controller.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
-#include "core/perf_stats.h"
 #include "core/settings.h"
-#include "core/telemetry_session.h"
-#include "video_core/debug_utils/debug_utils.h"
-#include "video_core/gpu.h"
+#include "file_sys/vfs_concat.h"
+#include "file_sys/vfs_real.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -38,9 +27,71 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
-namespace {
-FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
-                                         const std::string& path) {
+System::System() = default;
+
+System::~System() = default;
+
+/// Runs a CPU core while the system is powered on
+static void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
+    while (Core::System::GetInstance().IsPoweredOn()) {
+        cpu_state->RunLoop(true);
+    }
+}
+
+Cpu& System::CurrentCpuCore() {
+    // If multicore is enabled, use host thread to figure out the current CPU core
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+
+    // Otherwise, use single-threaded mode active_core variable
+    return *cpu_cores[active_core];
+}
+
+System::ResultStatus System::RunLoop(bool tight_loop) {
+    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];
+
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::HandlePacket();
+
+        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
+        // execute. Otherwise, get out of the loop function.
+        if (GDBStub::GetCpuHaltFlag()) {
+            if (GDBStub::GetCpuStepFlag()) {
+                tight_loop = false;
+            } else {
+                return ResultStatus::Success;
+            }
+        }
+    }
+
+    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+        cpu_cores[active_core]->RunLoop(tight_loop);
+        if (Settings::values.use_multi_core) {
+            // Cores 1-3 are run on other threads in this mode
+            break;
+        }
+    }
+
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::SetCpuStepFlag(false);
+    }
+
+    return status;
+}
+
+System::ResultStatus System::SingleStep() {
+    return RunLoop(false);
+}
+
+static FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
+                                                const std::string& path) {
     // To account for split 00+01+etc files.
     std::string dir_name;
     std::string filename;
@@ -70,405 +121,168 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 
-/// Runs a CPU core while the system is powered on
-void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
-    while (Core::System::GetInstance().IsPoweredOn()) {
-        cpu_state->RunLoop(true);
+System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
+    app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+
+    if (!app_loader) {
+        LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
+        return ResultStatus::ErrorGetLoader;
     }
-}
-} // Anonymous namespace
+    std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
+        app_loader->LoadKernelSystemMode();
 
-struct System::Impl {
-    Cpu& CurrentCpuCore() {
-        if (Settings::values.use_multi_core) {
-            const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-            ASSERT(search != thread_to_cpu.end());
-            ASSERT(search->second);
-            return *search->second;
-        }
-
-        // Otherwise, use single-threaded mode active_core variable
-        return *cpu_cores[active_core];
-    }
-
-    ResultStatus RunLoop(bool tight_loop) {
-        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];
-
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::HandlePacket();
-
-            // If the loop is halted and we want to step, use a tiny (1) number of instructions to
-            // execute. Otherwise, get out of the loop function.
-            if (GDBStub::GetCpuHaltFlag()) {
-                if (GDBStub::GetCpuStepFlag()) {
-                    tight_loop = false;
-                } else {
-                    return ResultStatus::Success;
-                }
-            }
-        }
-
-        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-            cpu_cores[active_core]->RunLoop(tight_loop);
-            if (Settings::values.use_multi_core) {
-                // Cores 1-3 are run on other threads in this mode
-                break;
-            }
-        }
-
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::SetCpuStepFlag(false);
-        }
-
-        return status;
-    }
-
-    ResultStatus Init(Frontend::EmuWindow& emu_window) {
-        LOG_DEBUG(HW_Memory, "initialized OK");
-
-        CoreTiming::Init();
-        kernel.Initialize();
-
-        // Create a default fs if one doesn't already exist.
-        if (virtual_filesystem == nullptr)
-            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
-
-        kernel.MakeCurrentProcess(Kernel::Process::Create(kernel, "main"));
-
-        cpu_barrier = std::make_shared<CpuBarrier>();
-        cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
-        for (size_t index = 0; index < cpu_cores.size(); ++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);
-        GDBStub::Init();
-
-        renderer = VideoCore::CreateRenderer(emu_window);
-        if (!renderer->Init()) {
-            return ResultStatus::ErrorVideoCore;
-        }
-
-        gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
-
-        // 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];
-        if (Settings::values.use_multi_core) {
-            for (size_t index = 0; index < cpu_core_threads.size(); ++index) {
-                cpu_core_threads[index] =
-                    std::make_unique<std::thread>(RunCpuCore, cpu_cores[index + 1]);
-                thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1];
-            }
-        }
-
-        LOG_DEBUG(Core, "Initialized OK");
-
-        // Reset counters and set time origin to current frame
-        GetAndResetPerfStats();
-        perf_stats.BeginSystemFrame();
-
-        return ResultStatus::Success;
-    }
-
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-        app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
-
-        if (!app_loader) {
-            LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
-            return ResultStatus::ErrorGetLoader;
-        }
-        std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
-            app_loader->LoadKernelSystemMode();
-
-        if (system_mode.second != Loader::ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
-                         static_cast<int>(system_mode.second));
+    if (system_mode.second != Loader::ResultStatus::Success) {
+        LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
+                     static_cast<int>(system_mode.second));
 
+        if (system_mode.second != Loader::ResultStatus::Success)
             return ResultStatus::ErrorSystemMode;
-        }
+    }
 
-        ResultStatus init_result{Init(emu_window)};
-        if (init_result != ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
-                         static_cast<int>(init_result));
-            Shutdown();
-            return init_result;
-        }
+    ResultStatus init_result{Init(emu_window)};
+    if (init_result != ResultStatus::Success) {
+        LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
+                     static_cast<int>(init_result));
+        System::Shutdown();
+        return init_result;
+    }
+
+    const Loader::ResultStatus load_result{app_loader->Load(current_process)};
+    if (Loader::ResultStatus::Success != load_result) {
+        LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
+        System::Shutdown();
 
-        const Loader::ResultStatus load_result{app_loader->Load(kernel.CurrentProcess())};
         if (load_result != Loader::ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
-            Shutdown();
-
             return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
                                              static_cast<u32>(load_result));
         }
-        status = ResultStatus::Success;
-        return status;
     }
-
-    void Shutdown() {
-        // Log last frame performance stats
-        auto perf_results = GetAndResetPerfStats();
-        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
-                             perf_results.emulation_speed * 100.0);
-        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
-                             perf_results.game_fps);
-        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
-                             perf_results.frametime * 1000.0);
-
-        // Shutdown emulation session
-        renderer.reset();
-        GDBStub::Shutdown();
-        Service::Shutdown();
-        service_manager.reset();
-        telemetry_session.reset();
-        gpu_core.reset();
-
-        // Close all CPU/threading state
-        cpu_barrier->NotifyEnd();
-        if (Settings::values.use_multi_core) {
-            for (auto& thread : cpu_core_threads) {
-                thread->join();
-                thread.reset();
-            }
-        }
-        thread_to_cpu.clear();
-        for (auto& cpu_core : cpu_cores) {
-            cpu_core.reset();
-        }
-        cpu_barrier.reset();
-
-        // Shutdown kernel and core timing
-        kernel.Shutdown();
-        CoreTiming::Shutdown();
-
-        // Close app loader
-        app_loader.reset();
-
-        LOG_DEBUG(Core, "Shutdown OK");
-    }
-
-    Loader::ResultStatus GetGameName(std::string& out) const {
-        if (app_loader == nullptr)
-            return Loader::ResultStatus::ErrorNotInitialized;
-        return app_loader->ReadTitle(out);
-    }
-
-    void SetStatus(ResultStatus new_status, const char* details = nullptr) {
-        status = new_status;
-        if (details) {
-            status_details = details;
-        }
-    }
-
-    PerfStatsResults GetAndResetPerfStats() {
-        return perf_stats.GetAndResetStats(CoreTiming::GetGlobalTimeUs());
-    }
-
-    Kernel::KernelCore kernel;
-    /// RealVfsFilesystem instance
-    FileSys::VirtualFilesystem virtual_filesystem;
-    /// AppLoader used to load the current executing application
-    std::unique_ptr<Loader::AppLoader> app_loader;
-    std::unique_ptr<VideoCore::RendererBase> renderer;
-    std::unique_ptr<Tegra::GPU> gpu_core;
-    std::shared_ptr<Tegra::DebugContext> debug_context;
-    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;
-    size_t active_core{}; ///< Active core, only used in single thread mode
-
-    /// Service manager
-    std::shared_ptr<Service::SM::ServiceManager> service_manager;
-
-    /// Telemetry session for this emulation session
-    std::unique_ptr<Core::TelemetrySession> telemetry_session;
-
-    ResultStatus status = ResultStatus::Success;
-    std::string status_details = "";
-
-    /// Map of guest threads to CPU cores
-    std::map<std::thread::id, std::shared_ptr<Cpu>> thread_to_cpu;
-
-    Core::PerfStats perf_stats;
-    Core::FrameLimiter frame_limiter;
-};
-
-System::System() : impl{std::make_unique<Impl>()} {}
-System::~System() = default;
-
-Cpu& System::CurrentCpuCore() {
-    return impl->CurrentCpuCore();
-}
-
-System::ResultStatus System::RunLoop(bool tight_loop) {
-    return impl->RunLoop(tight_loop);
-}
-
-System::ResultStatus System::SingleStep() {
-    return RunLoop(false);
-}
-
-void System::InvalidateCpuInstructionCaches() {
-    for (auto& cpu : impl->cpu_cores) {
-        cpu->ArmInterface().ClearInstructionCache();
-    }
-}
-
-System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    return impl->Load(emu_window, filepath);
-}
-
-bool System::IsPoweredOn() const {
-    return impl->cpu_barrier && impl->cpu_barrier->IsAlive();
+    status = ResultStatus::Success;
+    return status;
 }
 
 void System::PrepareReschedule() {
     CurrentCpuCore().PrepareReschedule();
 }
 
-PerfStatsResults System::GetAndResetPerfStats() {
-    return impl->GetAndResetPerfStats();
-}
-
-Core::TelemetrySession& System::TelemetrySession() const {
-    return *impl->telemetry_session;
-}
-
-ARM_Interface& System::CurrentArmInterface() {
-    return CurrentCpuCore().ArmInterface();
-}
-
-size_t System::CurrentCoreIndex() {
-    return CurrentCpuCore().CoreIndex();
-}
-
-Kernel::Scheduler& System::CurrentScheduler() {
-    return *CurrentCpuCore().Scheduler();
+PerfStats::Results System::GetAndResetPerfStats() {
+    return perf_stats.GetAndResetStats(CoreTiming::GetGlobalTimeUs());
 }
 
 const std::shared_ptr<Kernel::Scheduler>& System::Scheduler(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_cores[core_index]->Scheduler();
-}
-
-Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() {
-    return impl->kernel.CurrentProcess();
-}
-
-const Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() const {
-    return impl->kernel.CurrentProcess();
+    return cpu_cores[core_index]->Scheduler();
 }
 
 ARM_Interface& System::ArmInterface(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_cores[core_index]->ArmInterface();
+    return cpu_cores[core_index]->ArmInterface();
 }
 
 Cpu& System::CpuCore(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return *impl->cpu_cores[core_index];
-}
-
-ExclusiveMonitor& System::Monitor() {
-    return *impl->cpu_exclusive_monitor;
-}
-
-Tegra::GPU& System::GPU() {
-    return *impl->gpu_core;
-}
-
-const Tegra::GPU& System::GPU() const {
-    return *impl->gpu_core;
-}
-
-VideoCore::RendererBase& System::Renderer() {
-    return *impl->renderer;
-}
-
-const VideoCore::RendererBase& System::Renderer() const {
-    return *impl->renderer;
-}
-
-Kernel::KernelCore& System::Kernel() {
-    return impl->kernel;
-}
-
-const Kernel::KernelCore& System::Kernel() const {
-    return impl->kernel;
-}
-
-Core::PerfStats& System::GetPerfStats() {
-    return impl->perf_stats;
-}
-
-const Core::PerfStats& System::GetPerfStats() const {
-    return impl->perf_stats;
-}
-
-Core::FrameLimiter& System::FrameLimiter() {
-    return impl->frame_limiter;
-}
-
-const Core::FrameLimiter& System::FrameLimiter() const {
-    return impl->frame_limiter;
-}
-
-Loader::ResultStatus System::GetGameName(std::string& out) const {
-    return impl->GetGameName(out);
-}
-
-void System::SetStatus(ResultStatus new_status, const char* details) {
-    impl->SetStatus(new_status, details);
-}
-
-const std::string& System::GetStatusDetails() const {
-    return impl->status_details;
-}
-
-Loader::AppLoader& System::GetAppLoader() const {
-    return *impl->app_loader;
-}
-
-void System::SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context) {
-    impl->debug_context = std::move(context);
-}
-
-Tegra::DebugContext* System::GetGPUDebugContext() const {
-    return impl->debug_context.get();
-}
-
-void System::SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs) {
-    impl->virtual_filesystem = std::move(vfs);
-}
-
-std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
-    return impl->virtual_filesystem;
+    return *cpu_cores[core_index];
 }
 
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(emu_window);
+    LOG_DEBUG(HW_Memory, "initialized OK");
+
+    CoreTiming::Init();
+
+    // Create a default fs if one doesn't already exist.
+    if (virtual_filesystem == nullptr)
+        virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
+
+    current_process = Kernel::Process::Create("main");
+
+    cpu_barrier = std::make_shared<CpuBarrier>();
+    cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
+    for (size_t index = 0; index < cpu_cores.size(); ++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>();
+
+    Kernel::Init();
+    Service::Init(service_manager, virtual_filesystem);
+    GDBStub::Init();
+
+    renderer = VideoCore::CreateRenderer(emu_window);
+    if (!renderer->Init()) {
+        return ResultStatus::ErrorVideoCore;
+    }
+
+    gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
+
+    // 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];
+    if (Settings::values.use_multi_core) {
+        for (size_t index = 0; index < cpu_core_threads.size(); ++index) {
+            cpu_core_threads[index] =
+                std::make_unique<std::thread>(RunCpuCore, cpu_cores[index + 1]);
+            thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1];
+        }
+    }
+
+    LOG_DEBUG(Core, "Initialized OK");
+
+    // Reset counters and set time origin to current frame
+    GetAndResetPerfStats();
+    perf_stats.BeginSystemFrame();
+
+    return ResultStatus::Success;
 }
 
 void System::Shutdown() {
-    impl->Shutdown();
+    // Log last frame performance stats
+    auto perf_results = GetAndResetPerfStats();
+    Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
+                         perf_results.emulation_speed * 100.0);
+    Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
+                         perf_results.game_fps);
+    Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
+                         perf_results.frametime * 1000.0);
+
+    // Shutdown emulation session
+    renderer.reset();
+    GDBStub::Shutdown();
+    Service::Shutdown();
+    Kernel::Shutdown();
+    service_manager.reset();
+    telemetry_session.reset();
+    gpu_core.reset();
+
+    // Close all CPU/threading state
+    cpu_barrier->NotifyEnd();
+    if (Settings::values.use_multi_core) {
+        for (auto& thread : cpu_core_threads) {
+            thread->join();
+            thread.reset();
+        }
+    }
+    thread_to_cpu.clear();
+    for (auto& cpu_core : cpu_cores) {
+        cpu_core.reset();
+    }
+    cpu_barrier.reset();
+
+    // Close core timing
+    CoreTiming::Shutdown();
+
+    // Close app loader
+    app_loader.reset();
+
+    LOG_DEBUG(Core, "Shutdown OK");
 }
 
 Service::SM::ServiceManager& System::ServiceManager() {
-    return *impl->service_manager;
+    return *service_manager;
 }
 
 const Service::SM::ServiceManager& System::ServiceManager() const {
-    return *impl->service_manager;
+    return *service_manager;
 }
 
 } // namespace Core

src/core/core.h

@@ -4,56 +4,40 @@
 
 #pragma once
 
-#include <cstddef>
+#include <array>
 #include <memory>
 #include <string>
-
+#include <thread>
 #include "common/common_types.h"
+#include "core/arm/exclusive_monitor.h"
+#include "core/core_cpu.h"
 #include "core/hle/kernel/object.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/loader/loader.h"
+#include "core/memory.h"
+#include "core/perf_stats.h"
+#include "core/telemetry_session.h"
+#include "file_sys/vfs_real.h"
+#include "hle/service/filesystem/filesystem.h"
+#include "video_core/debug_utils/debug_utils.h"
+#include "video_core/gpu.h"
+
+class ARM_Interface;
 
 namespace Core::Frontend {
 class EmuWindow;
-} // namespace Core::Frontend
-
-namespace FileSys {
-class VfsFilesystem;
-} // namespace FileSys
-
-namespace Kernel {
-class KernelCore;
-class Process;
-class Scheduler;
-} // namespace Kernel
-
-namespace Loader {
-class AppLoader;
-enum class ResultStatus : u16;
-} // namespace Loader
+}
 
 namespace Service::SM {
 class ServiceManager;
-} // namespace Service::SM
-
-namespace Tegra {
-class DebugContext;
-class GPU;
-} // namespace Tegra
+}
 
 namespace VideoCore {
 class RendererBase;
-} // namespace VideoCore
+}
 
 namespace Core {
 
-class ARM_Interface;
-class Cpu;
-class ExclusiveMonitor;
-class FrameLimiter;
-class PerfStats;
-class TelemetrySession;
-
-struct PerfStatsResults;
-
 class System {
 public:
     System(const System&) = delete;
@@ -108,7 +92,11 @@ public:
      * This function should only be used by GDB Stub to support breakpoints, memory updates and
      * step/continue commands.
      */
-    void InvalidateCpuInstructionCaches();
+    void InvalidateCpuInstructionCaches() {
+        for (auto& cpu : cpu_cores) {
+            cpu->ArmInterface().ClearInstructionCache();
+        }
+    }
 
     /// Shutdown the emulated system.
     void Shutdown();
@@ -127,28 +115,33 @@ public:
      * application).
      * @returns True if the emulated system is powered on, otherwise false.
      */
-    bool IsPoweredOn() const;
+    bool IsPoweredOn() const {
+        return cpu_barrier && cpu_barrier->IsAlive();
+    }
 
     /**
      * Returns a reference to the telemetry session for this emulation session.
      * @returns Reference to the telemetry session.
      */
-    Core::TelemetrySession& TelemetrySession() const;
+    Core::TelemetrySession& TelemetrySession() const {
+        return *telemetry_session;
+    }
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
 
     /// Gets and resets core performance statistics
-    PerfStatsResults GetAndResetPerfStats();
+    PerfStats::Results GetAndResetPerfStats();
 
     /// Gets an ARM interface to the CPU core that is currently running
-    ARM_Interface& CurrentArmInterface();
+    ARM_Interface& CurrentArmInterface() {
+        return CurrentCpuCore().ArmInterface();
+    }
 
     /// Gets the index of the currently running CPU core
-    size_t CurrentCoreIndex();
-
-    /// Gets the scheduler for the CPU core that is currently running
-    Kernel::Scheduler& CurrentScheduler();
+    size_t CurrentCoreIndex() {
+        return CurrentCpuCore().CoreIndex();
+    }
 
     /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(size_t core_index);
@@ -156,67 +149,80 @@ public:
     /// Gets a CPU interface to the CPU core with the specified index
     Cpu& CpuCore(size_t core_index);
 
-    /// Gets the exclusive monitor
-    ExclusiveMonitor& Monitor();
-
     /// Gets a mutable reference to the GPU interface
-    Tegra::GPU& GPU();
+    Tegra::GPU& GPU() {
+        return *gpu_core;
+    }
 
     /// Gets an immutable reference to the GPU interface.
-    const Tegra::GPU& GPU() const;
+    const Tegra::GPU& GPU() const {
+        return *gpu_core;
+    }
 
     /// Gets a mutable reference to the renderer.
-    VideoCore::RendererBase& Renderer();
+    VideoCore::RendererBase& Renderer() {
+        return *renderer;
+    }
 
     /// Gets an immutable reference to the renderer.
-    const VideoCore::RendererBase& Renderer() const;
+    const VideoCore::RendererBase& Renderer() const {
+        return *renderer;
+    }
+
+    /// Gets the scheduler for the CPU core that is currently running
+    Kernel::Scheduler& CurrentScheduler() {
+        return *CurrentCpuCore().Scheduler();
+    }
+
+    /// Gets the exclusive monitor
+    ExclusiveMonitor& Monitor() {
+        return *cpu_exclusive_monitor;
+    }
 
     /// Gets the scheduler for the CPU core with the specified index
     const std::shared_ptr<Kernel::Scheduler>& Scheduler(size_t core_index);
 
-    /// Provides a reference to the current process
-    Kernel::SharedPtr<Kernel::Process>& CurrentProcess();
+    /// Gets the current process
+    Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
+        return current_process;
+    }
 
-    /// Provides a constant reference to the current process.
-    const Kernel::SharedPtr<Kernel::Process>& CurrentProcess() const;
+    PerfStats perf_stats;
+    FrameLimiter frame_limiter;
 
-    /// Provides a reference to the kernel instance.
-    Kernel::KernelCore& Kernel();
+    void SetStatus(ResultStatus new_status, const char* details = nullptr) {
+        status = new_status;
+        if (details) {
+            status_details = details;
+        }
+    }
 
-    /// Provides a constant reference to the kernel instance.
-    const Kernel::KernelCore& Kernel() const;
+    const std::string& GetStatusDetails() const {
+        return status_details;
+    }
 
-    /// Provides a reference to the internal PerfStats instance.
-    Core::PerfStats& GetPerfStats();
-
-    /// Provides a constant reference to the internal PerfStats instance.
-    const Core::PerfStats& GetPerfStats() const;
-
-    /// Provides a reference to the frame limiter;
-    Core::FrameLimiter& FrameLimiter();
-
-    /// Provides a constant referent to the frame limiter
-    const Core::FrameLimiter& FrameLimiter() const;
-
-    /// Gets the name of the current game
-    Loader::ResultStatus GetGameName(std::string& out) const;
-
-    void SetStatus(ResultStatus new_status, const char* details);
-
-    const std::string& GetStatusDetails() const;
-
-    Loader::AppLoader& GetAppLoader() const;
+    Loader::AppLoader& GetAppLoader() const {
+        return *app_loader;
+    }
 
     Service::SM::ServiceManager& ServiceManager();
     const Service::SM::ServiceManager& ServiceManager() const;
 
-    void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context);
+    void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context) {
+        debug_context = std::move(context);
+    }
 
-    Tegra::DebugContext* GetGPUDebugContext() const;
+    std::shared_ptr<Tegra::DebugContext> GetGPUDebugContext() const {
+        return debug_context;
+    }
 
-    void SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs);
+    void SetFilesystem(FileSys::VirtualFilesystem vfs) {
+        virtual_filesystem = std::move(vfs);
+    }
 
-    std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
+    FileSys::VirtualFilesystem GetFilesystem() const {
+        return virtual_filesystem;
+    }
 
 private:
     System();
@@ -232,10 +238,33 @@ private:
      */
     ResultStatus Init(Frontend::EmuWindow& emu_window);
 
-    struct Impl;
-    std::unique_ptr<Impl> impl;
+    /// RealVfsFilesystem instance
+    FileSys::VirtualFilesystem virtual_filesystem;
+    /// AppLoader used to load the current executing application
+    std::unique_ptr<Loader::AppLoader> app_loader;
+    std::unique_ptr<VideoCore::RendererBase> renderer;
+    std::unique_ptr<Tegra::GPU> gpu_core;
+    std::shared_ptr<Tegra::DebugContext> debug_context;
+    Kernel::SharedPtr<Kernel::Process> current_process;
+    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;
+    size_t active_core{}; ///< Active core, only used in single thread mode
+
+    /// Service manager
+    std::shared_ptr<Service::SM::ServiceManager> service_manager;
+
+    /// Telemetry session for this emulation session
+    std::unique_ptr<Core::TelemetrySession> telemetry_session;
 
     static System s_instance;
+
+    ResultStatus status = ResultStatus::Success;
+    std::string status_details = "";
+
+    /// Map of guest threads to CPU cores
+    std::map<std::thread::id, std::shared_ptr<Cpu>> thread_to_cpu;
 };
 
 inline ARM_Interface& CurrentArmInterface() {

src/core/core_cpu.h

@@ -12,14 +12,14 @@
 #include "common/common_types.h"
 #include "core/arm/exclusive_monitor.h"
 
+class ARM_Interface;
+
 namespace Kernel {
 class Scheduler;
 }
 
 namespace Core {
 
-class ARM_Interface;
-
 constexpr unsigned NUM_CPU_CORES{4};
 
 class CpuBarrier {

src/core/crypto/aes_util.cpp

@@ -82,25 +82,11 @@ void AESCipher<Key, KeySize>::Transcode(const u8* src, size_t size, u8* dest, Op
         }
     } else {
         const auto block_size = mbedtls_cipher_get_block_size(context);
-        if (size < block_size) {
-            std::vector<u8> block(block_size);
-            std::memcpy(block.data(), src, size);
-            Transcode(block.data(), block.size(), block.data(), op);
-            std::memcpy(dest, block.data(), size);
-            return;
-        }
 
         for (size_t offset = 0; offset < size; offset += block_size) {
             auto length = std::min<size_t>(block_size, size - offset);
             mbedtls_cipher_update(context, src + offset, length, dest + offset, &written);
             if (written != length) {
-                if (length < block_size) {
-                    std::vector<u8> block(block_size);
-                    std::memcpy(block.data(), src + offset, length);
-                    Transcode(block.data(), block.size(), block.data(), op);
-                    std::memcpy(dest + offset, block.data(), length);
-                    return;
-                }
                 LOG_WARNING(Crypto, "Not all data was decrypted requested={:016X}, actual={:016X}.",
                             length, written);
             }
@@ -113,7 +99,10 @@ void AESCipher<Key, KeySize>::Transcode(const u8* src, size_t size, u8* dest, Op
 template <typename Key, size_t KeySize>
 void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, size_t size, u8* dest, size_t sector_id,
                                            size_t sector_size, Op op) {
-    ASSERT_MSG(size % sector_size == 0, "XTS decryption size must be a multiple of sector size.");
+    if (size % sector_size > 0) {
+        LOG_CRITICAL(Crypto, "Data size must be a multiple of sector size.");
+        return;
+    }
 
     for (size_t i = 0; i < size; i += sector_size) {
         SetIV(CalculateNintendoTweak(sector_id++));
@@ -123,4 +112,4 @@ void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, size_t size, u8* dest,
 
 template class AESCipher<Key128>;
 template class AESCipher<Key256>;
-} // namespace Core::Crypto
+} // namespace Core::Crypto

src/core/crypto/ctr_encryption_layer.cpp

@@ -20,7 +20,9 @@ size_t CTREncryptionLayer::Read(u8* data, size_t length, size_t offset) const {
     if (sector_offset == 0) {
         UpdateIV(base_offset + offset);
         std::vector<u8> raw = base->ReadBytes(length, offset);
-        cipher.Transcode(raw.data(), raw.size(), data, Op::Decrypt);
+        if (raw.size() != length)
+            return Read(data, raw.size(), offset);
+        cipher.Transcode(raw.data(), length, data, Op::Decrypt);
         return length;
     }
 
@@ -32,7 +34,7 @@ size_t CTREncryptionLayer::Read(u8* data, size_t length, size_t offset) const {
 
     if (length + sector_offset < 0x10) {
         std::memcpy(data, block.data() + sector_offset, std::min<u64>(length, read));
-        return std::min<u64>(length, read);
+        return read;
     }
     std::memcpy(data, block.data() + sector_offset, read);
     return read + Read(data + read, length - read, offset + read);

src/core/crypto/key_manager.cpp

@@ -8,119 +8,15 @@
 #include <locale>
 #include <sstream>
 #include <string_view>
-#include <tuple>
-#include <vector>
 #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/loader/loader.h"
 #include "core/settings.h"
 
 namespace Core::Crypto {
 
-Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed) {
-    Key128 out{};
-
-    AESCipher<Key128> cipher1(master, Mode::ECB);
-    cipher1.Transcode(kek_seed.data(), kek_seed.size(), out.data(), Op::Decrypt);
-    AESCipher<Key128> cipher2(out, Mode::ECB);
-    cipher2.Transcode(source.data(), source.size(), out.data(), Op::Decrypt);
-
-    if (key_seed != Key128{}) {
-        AESCipher<Key128> cipher3(out, Mode::ECB);
-        cipher3.Transcode(key_seed.data(), key_seed.size(), out.data(), Op::Decrypt);
-    }
-
-    return out;
-}
-
-boost::optional<Key128> DeriveSDSeed() {
-    const FileUtil::IOFile save_43(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                                       "/system/save/8000000000000043",
-                                   "rb+");
-    if (!save_43.IsOpen())
-        return boost::none;
-    const FileUtil::IOFile sd_private(
-        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir) + "/Nintendo/Contents/private", "rb+");
-    if (!sd_private.IsOpen())
-        return boost::none;
-
-    sd_private.Seek(0, SEEK_SET);
-    std::array<u8, 0x10> private_seed{};
-    if (sd_private.ReadBytes(private_seed.data(), private_seed.size()) != 0x10)
-        return boost::none;
-
-    std::array<u8, 0x10> buffer{};
-    size_t offset = 0;
-    for (; offset + 0x10 < save_43.GetSize(); ++offset) {
-        save_43.Seek(offset, SEEK_SET);
-        save_43.ReadBytes(buffer.data(), buffer.size());
-        if (buffer == private_seed)
-            break;
-    }
-
-    if (offset + 0x10 >= save_43.GetSize())
-        return boost::none;
-
-    Key128 seed{};
-    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, 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)))
-        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));
-    const auto aes_kek_gen =
-        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);
-
-    if (!keys.HasKey(S128KeyType::SDSeed))
-        return Loader::ResultStatus::ErrorMissingSDSeed;
-    const auto sd_seed = keys.GetKey(S128KeyType::SDSeed);
-
-    if (!keys.HasKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::Save)))
-        return Loader::ResultStatus::ErrorMissingSDSaveKeySource;
-    if (!keys.HasKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::NCA)))
-        return Loader::ResultStatus::ErrorMissingSDNCAKeySource;
-
-    std::array<Key256, 2> sd_key_sources{
-        keys.GetKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::Save)),
-        keys.GetKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::NCA)),
-    };
-
-    // Combine sources and seed
-    for (auto& source : sd_key_sources) {
-        for (size_t i = 0; i < source.size(); ++i)
-            source[i] ^= sd_seed[i & 0xF];
-    }
-
-    AESCipher<Key128> cipher(sd_kek, Mode::ECB);
-    // The transform manipulates sd_keys as part of the Transcode, so the return/output is
-    // unnecessary. This does not alter sd_keys_sources.
-    std::transform(sd_key_sources.begin(), sd_key_sources.end(), sd_keys.begin(),
-                   sd_key_sources.begin(), [&cipher](const Key256& source, Key256& out) {
-                       cipher.Transcode(source.data(), source.size(), out.data(), Op::Decrypt);
-                       return source; ///< Return unaltered source to satisfy output requirement.
-                   });
-
-    return Loader::ResultStatus::Success;
-}
-
 KeyManager::KeyManager() {
     // Initialize keys
     const std::string hactool_keys_dir = FileUtil::GetHactoolConfigurationPath();
@@ -128,15 +24,12 @@ KeyManager::KeyManager() {
     if (Settings::values.use_dev_keys) {
         dev_mode = true;
         AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "dev.keys", false);
-        AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "dev.keys_autogenerated", false);
     } else {
         dev_mode = false;
         AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "prod.keys", false);
-        AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "prod.keys_autogenerated", false);
     }
 
     AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "title.keys", true);
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "title.keys_autogenerated", true);
 }
 
 void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
@@ -163,17 +56,17 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
             u128 rights_id{};
             std::memcpy(rights_id.data(), rights_id_raw.data(), rights_id_raw.size());
             Key128 key = Common::HexStringToArray<16>(out[1]);
-            s128_keys[{S128KeyType::Titlekey, rights_id[1], rights_id[0]}] = key;
+            SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
         } else {
             std::transform(out[0].begin(), out[0].end(), out[0].begin(), ::tolower);
             if (s128_file_id.find(out[0]) != s128_file_id.end()) {
                 const auto index = s128_file_id.at(out[0]);
                 Key128 key = Common::HexStringToArray<16>(out[1]);
-                s128_keys[{index.type, index.field1, index.field2}] = key;
+                SetKey(index.type, key, index.field1, index.field2);
             } else if (s256_file_id.find(out[0]) != s256_file_id.end()) {
                 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;
+                SetKey(index.type, key, index.field1, index.field2);
             }
         }
     }
@@ -207,60 +100,11 @@ Key256 KeyManager::GetKey(S256KeyType id, u64 field1, u64 field2) const {
     return s256_keys.at({id, field1, field2});
 }
 
-template <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 (!title_key)
-        filename = dev_mode ? "dev.keys_autogenerated" : "prod.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);
-    if (!file.is_open())
-        return;
-    if (add_info_text) {
-        file
-            << "# This file is autogenerated by Yuzu\n"
-            << "# It serves to store keys that were automatically generated from the normal keys\n"
-            << "# If you are experiencing issues involving keys, it may help to delete this file\n";
-    }
-
-    file << fmt::format("\n{} = {}", keyname, Common::HexArrayToString(key));
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, filename, title_key);
-}
-
 void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
-    if (s128_keys.find({id, field1, field2}) != s128_keys.end())
-        return;
-    if (id == S128KeyType::Titlekey) {
-        Key128 rights_id;
-        std::memcpy(rights_id.data(), &field2, sizeof(u64));
-        std::memcpy(rights_id.data() + sizeof(u64), &field1, sizeof(u64));
-        WriteKeyToFile(true, Common::HexArrayToString(rights_id), key);
-    }
-    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) {
-            return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
-                   std::tie(id, field1, field2);
-        });
-    if (iter2 != s128_file_id.end())
-        WriteKeyToFile(false, iter2->first, key);
     s128_keys[{id, field1, field2}] = key;
 }
 
 void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
-    if (s256_keys.find({id, field1, field2}) != s256_keys.end())
-        return;
-    const auto iter = std::find_if(
-        s256_file_id.begin(), s256_file_id.end(),
-        [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S256KeyType>> elem) {
-            return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
-                   std::tie(id, field1, field2);
-        });
-    if (iter != s256_file_id.end())
-        WriteKeyToFile(false, iter->first, key);
     s256_keys[{id, field1, field2}] = key;
 }
 
@@ -281,16 +125,7 @@ bool KeyManager::KeyFileExists(bool title) {
            FileUtil::Exists(yuzu_keys_dir + DIR_SEP + "prod.keys");
 }
 
-void KeyManager::DeriveSDSeedLazy() {
-    if (HasKey(S128KeyType::SDSeed))
-        return;
-
-    const auto res = DeriveSDSeed();
-    if (res != boost::none)
-        SetKey(S128KeyType::SDSeed, res.get());
-}
-
-const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager::s128_file_id = {
+const std::unordered_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}},
@@ -332,17 +167,11 @@ const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager:
     {"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}},
-    {"aes_key_generation_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration), 0}},
-    {"sd_seed", {S128KeyType::SDSeed, 0, 0}},
 };
 
-const boost::container::flat_map<std::string, KeyIndex<S256KeyType>> KeyManager::s256_file_id = {
+const std::unordered_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}},
+    {"sd_card_save_key", {S256KeyType::SDSave, 0, 0}},
+    {"sd_card_nca_key", {S256KeyType::SDNCA, 0, 0}},
 };
 } // namespace Core::Crypto

src/core/crypto/key_manager.h

@@ -6,19 +6,14 @@
 
 #include <array>
 #include <string>
-#include <boost/container/flat_map.hpp>
-#include <boost/optional.hpp>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
 #include <fmt/format.h>
 #include "common/common_types.h"
 
-namespace Loader {
-enum class ResultStatus : u16;
-}
-
 namespace Core::Crypto {
 
-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>;
@@ -27,8 +22,9 @@ static_assert(sizeof(Key128) == 16, "Key128 must be 128 bytes big.");
 static_assert(sizeof(Key256) == 32, "Key128 must be 128 bytes big.");
 
 enum class S256KeyType : u64 {
-    Header,      //
-    SDKeySource, // f1=SDKeyType
+    Header, //
+    SDSave, //
+    SDNCA,  //
 };
 
 enum class S128KeyType : u64 {
@@ -40,7 +36,6 @@ enum class S128KeyType : u64 {
     KeyArea,       // f1=crypto revision f2=type {app, ocean, system}
     SDSeed,        //
     Titlekey,      // f1=rights id LSB f2=rights id MSB
-    Source,        // f1=source type, f2= sub id
 };
 
 enum class KeyAreaKeyType : u8 {
@@ -49,17 +44,6 @@ enum class KeyAreaKeyType : u8 {
     System,
 };
 
-enum class SourceKeyType : u8 {
-    SDKEK,
-    AESKEKGeneration,
-    AESKeyGeneration,
-};
-
-enum class SDKeyType : u8 {
-    Save,
-    NCA,
-};
-
 template <typename KeyType>
 struct KeyIndex {
     KeyType type;
@@ -75,12 +59,34 @@ struct KeyIndex {
     }
 };
 
-// boost flat_map requires operator< for O(log(n)) lookups.
+// The following two (== and hash) are so KeyIndex can be a key in unordered_map
+
 template <typename KeyType>
-bool operator<(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
-    return std::tie(lhs.type, lhs.field1, lhs.field2) < std::tie(rhs.type, rhs.field1, rhs.field2);
+bool operator==(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
+    return std::tie(lhs.type, lhs.field1, lhs.field2) == std::tie(rhs.type, rhs.field1, rhs.field2);
 }
 
+template <typename KeyType>
+bool operator!=(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
+    return !operator==(lhs, rhs);
+}
+
+} // namespace Core::Crypto
+
+namespace std {
+template <typename KeyType>
+struct hash<Core::Crypto::KeyIndex<KeyType>> {
+    size_t operator()(const Core::Crypto::KeyIndex<KeyType>& k) const {
+        using std::hash;
+
+        return ((hash<u64>()(static_cast<u64>(k.type)) ^ (hash<u64>()(k.field1) << 1)) >> 1) ^
+               (hash<u64>()(k.field2) << 1);
+    }
+};
+} // namespace std
+
+namespace Core::Crypto {
+
 class KeyManager {
 public:
     KeyManager();
@@ -96,27 +102,16 @@ public:
 
     static bool KeyFileExists(bool title);
 
-    // Call before using the sd seed to attempt to derive it if it dosen't exist. Needs system save
-    // 8*43 and the private file to exist.
-    void DeriveSDSeedLazy();
-
 private:
-    boost::container::flat_map<KeyIndex<S128KeyType>, Key128> s128_keys;
-    boost::container::flat_map<KeyIndex<S256KeyType>, Key256> s256_keys;
+    std::unordered_map<KeyIndex<S128KeyType>, Key128> s128_keys;
+    std::unordered_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(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;
+    static const std::unordered_map<std::string, KeyIndex<S128KeyType>> s128_file_id;
+    static const std::unordered_map<std::string, KeyIndex<S256KeyType>> s256_file_id;
 };
-
-Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed);
-boost::optional<Key128> DeriveSDSeed();
-Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, const KeyManager& keys);
-
 } // namespace Core::Crypto

src/core/crypto/xts_encryption_layer.cpp

@@ -1,58 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstring>
-#include "common/assert.h"
-#include "core/crypto/xts_encryption_layer.h"
-
-namespace Core::Crypto {
-
-constexpr u64 XTS_SECTOR_SIZE = 0x4000;
-
-XTSEncryptionLayer::XTSEncryptionLayer(FileSys::VirtualFile base_, Key256 key_)
-    : EncryptionLayer(std::move(base_)), cipher(key_, Mode::XTS) {}
-
-size_t XTSEncryptionLayer::Read(u8* data, size_t length, size_t offset) const {
-    if (length == 0)
-        return 0;
-
-    const auto sector_offset = offset & 0x3FFF;
-    if (sector_offset == 0) {
-        if (length % XTS_SECTOR_SIZE == 0) {
-            std::vector<u8> raw = base->ReadBytes(length, offset);
-            cipher.XTSTranscode(raw.data(), raw.size(), data, offset / XTS_SECTOR_SIZE,
-                                XTS_SECTOR_SIZE, Op::Decrypt);
-            return raw.size();
-        }
-        if (length > XTS_SECTOR_SIZE) {
-            const auto rem = length % XTS_SECTOR_SIZE;
-            const auto read = length - rem;
-            return Read(data, read, offset) + Read(data + read, rem, offset + read);
-        }
-        std::vector<u8> buffer = base->ReadBytes(XTS_SECTOR_SIZE, offset);
-        if (buffer.size() < XTS_SECTOR_SIZE)
-            buffer.resize(XTS_SECTOR_SIZE);
-        cipher.XTSTranscode(buffer.data(), buffer.size(), buffer.data(), offset / XTS_SECTOR_SIZE,
-                            XTS_SECTOR_SIZE, Op::Decrypt);
-        std::memcpy(data, buffer.data(), std::min(buffer.size(), length));
-        return std::min(buffer.size(), length);
-    }
-
-    // offset does not fall on block boundary (0x4000)
-    std::vector<u8> block = base->ReadBytes(0x4000, offset - sector_offset);
-    if (block.size() < XTS_SECTOR_SIZE)
-        block.resize(XTS_SECTOR_SIZE);
-    cipher.XTSTranscode(block.data(), block.size(), block.data(),
-                        (offset - sector_offset) / XTS_SECTOR_SIZE, XTS_SECTOR_SIZE, Op::Decrypt);
-    const size_t read = XTS_SECTOR_SIZE - sector_offset;
-
-    if (length + sector_offset < XTS_SECTOR_SIZE) {
-        std::memcpy(data, block.data() + sector_offset, std::min<u64>(length, read));
-        return std::min<u64>(length, read);
-    }
-    std::memcpy(data, block.data() + sector_offset, read);
-    return read + Read(data + read, length - read, offset + read);
-}
-} // namespace Core::Crypto

src/core/crypto/xts_encryption_layer.h

@@ -1,25 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/crypto/aes_util.h"
-#include "core/crypto/encryption_layer.h"
-#include "core/crypto/key_manager.h"
-
-namespace Core::Crypto {
-
-// Sits on top of a VirtualFile and provides XTS-mode AES decription.
-class XTSEncryptionLayer : public EncryptionLayer {
-public:
-    XTSEncryptionLayer(FileSys::VirtualFile base, Key256 key);
-
-    size_t Read(u8* data, size_t length, size_t offset) const override;
-
-private:
-    // Must be mutable as operations modify cipher contexts.
-    mutable AESCipher<Key256> cipher;
-};
-
-} // namespace Core::Crypto

src/core/file_sys/bis_factory.cpp

@@ -3,18 +3,22 @@
 // Refer to the license.txt file included.
 
 #include "core/file_sys/bis_factory.h"
-#include "core/file_sys/registered_cache.h"
 
 namespace FileSys {
 
+static VirtualDir GetOrCreateDirectory(const VirtualDir& dir, std::string_view path) {
+    const auto res = dir->GetDirectoryRelative(path);
+    if (res == nullptr)
+        return dir->CreateDirectoryRelative(path);
+    return res;
+}
+
 BISFactory::BISFactory(VirtualDir nand_root_)
     : nand_root(std::move(nand_root_)),
       sysnand_cache(std::make_shared<RegisteredCache>(
-          GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
+          GetOrCreateDirectory(nand_root, "/system/Contents/registered"))),
       usrnand_cache(std::make_shared<RegisteredCache>(
-          GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))) {}
-
-BISFactory::~BISFactory() = default;
+          GetOrCreateDirectory(nand_root, "/user/Contents/registered"))) {}
 
 std::shared_ptr<RegisteredCache> BISFactory::GetSystemNANDContents() const {
     return sysnand_cache;

src/core/file_sys/bis_factory.h

@@ -5,20 +5,17 @@
 #pragma once
 
 #include <memory>
-
-#include "core/file_sys/vfs.h"
+#include "core/loader/loader.h"
+#include "registered_cache.h"
 
 namespace FileSys {
 
-class RegisteredCache;
-
 /// File system interface to the Built-In Storage
 /// This is currently missing accessors to BIS partitions, but seemed like a good place for the NAND
 /// registered caches.
 class BISFactory {
 public:
     explicit BISFactory(VirtualDir nand_root);
-    ~BISFactory();
 
     std::shared_ptr<RegisteredCache> GetSystemNANDContents() const;
     std::shared_ptr<RegisteredCache> GetUserNANDContents() const;

src/core/file_sys/card_image.cpp

@@ -9,10 +9,7 @@
 
 #include "common/logging/log.h"
 #include "core/file_sys/card_image.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/submission_package.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
 
@@ -46,19 +43,13 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
             partitions[static_cast<size_t>(partition)] = std::make_shared<PartitionFilesystem>(raw);
     }
 
-    secure_partition = std::make_shared<NSP>(
-        main_hfs.GetFile(partition_names[static_cast<size_t>(XCIPartition::Secure)]));
+    auto result = AddNCAFromPartition(XCIPartition::Secure);
+    if (result != Loader::ResultStatus::Success) {
+        status = result;
+        return;
+    }
 
-    const auto secure_ncas = secure_partition->GetNCAsCollapsed();
-    std::copy(secure_ncas.begin(), secure_ncas.end(), std::back_inserter(ncas));
-
-    program =
-        secure_partition->GetNCA(secure_partition->GetProgramTitleID(), ContentRecordType::Program);
-    program_nca_status = secure_partition->GetProgramStatus(secure_partition->GetProgramTitleID());
-    if (program_nca_status == Loader::ResultStatus::ErrorNSPMissingProgramNCA)
-        program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
-
-    auto result = AddNCAFromPartition(XCIPartition::Update);
+    result = AddNCAFromPartition(XCIPartition::Update);
     if (result != Loader::ResultStatus::Success) {
         status = result;
         return;
@@ -81,24 +72,14 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
     status = Loader::ResultStatus::Success;
 }
 
-XCI::~XCI() = default;
-
 Loader::ResultStatus XCI::GetStatus() const {
     return status;
 }
 
-Loader::ResultStatus XCI::GetProgramNCAStatus() const {
-    return program_nca_status;
-}
-
 VirtualDir XCI::GetPartition(XCIPartition partition) const {
     return partitions[static_cast<size_t>(partition)];
 }
 
-std::shared_ptr<NSP> XCI::GetSecurePartitionNSP() const {
-    return secure_partition;
-}
-
 VirtualDir XCI::GetSecurePartition() const {
     return GetPartition(XCIPartition::Secure);
 }
@@ -115,20 +96,6 @@ VirtualDir XCI::GetLogoPartition() const {
     return GetPartition(XCIPartition::Logo);
 }
 
-u64 XCI::GetProgramTitleID() const {
-    return secure_partition->GetProgramTitleID();
-}
-
-std::shared_ptr<NCA> XCI::GetProgramNCA() const {
-    return program;
-}
-
-VirtualFile XCI::GetProgramNCAFile() const {
-    if (GetProgramNCA() == nullptr)
-        return nullptr;
-    return GetProgramNCA()->GetBaseFile();
-}
-
 const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
     return ncas;
 }
@@ -176,12 +143,6 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
         if (file->GetExtension() != "nca")
             continue;
         auto nca = std::make_shared<NCA>(file);
-        // TODO(DarkLordZach): Add proper Rev1+ Support
-        if (nca->IsUpdate())
-            continue;
-        if (nca->GetType() == NCAContentType::Program) {
-            program_nca_status = nca->GetStatus();
-        }
         if (nca->GetStatus() == Loader::ResultStatus::Success) {
             ncas.push_back(std::move(nca));
         } else {

src/core/file_sys/card_image.h

@@ -5,22 +5,15 @@
 #pragma once
 
 #include <array>
-#include <memory>
 #include <vector>
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/file_sys/content_archive.h"
 #include "core/file_sys/vfs.h"
-
-namespace Loader {
-enum class ResultStatus : u16;
-}
+#include "core/loader/loader.h"
 
 namespace FileSys {
 
-class NCA;
-enum class NCAContentType : u8;
-class NSP;
-
 enum class GamecardSize : u8 {
     S_1GB = 0xFA,
     S_2GB = 0xF8,
@@ -64,24 +57,17 @@ enum class XCIPartition : u8 { Update, Normal, Secure, Logo };
 class XCI : public ReadOnlyVfsDirectory {
 public:
     explicit XCI(VirtualFile file);
-    ~XCI() override;
 
     Loader::ResultStatus GetStatus() const;
-    Loader::ResultStatus GetProgramNCAStatus() const;
 
     u8 GetFormatVersion() const;
 
     VirtualDir GetPartition(XCIPartition partition) const;
-    std::shared_ptr<NSP> GetSecurePartitionNSP() const;
     VirtualDir GetSecurePartition() const;
     VirtualDir GetNormalPartition() const;
     VirtualDir GetUpdatePartition() const;
     VirtualDir GetLogoPartition() const;
 
-    u64 GetProgramTitleID() 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;
     VirtualFile GetNCAFileByType(NCAContentType type) const;
@@ -104,11 +90,8 @@ private:
     GamecardHeader header{};
 
     Loader::ResultStatus status;
-    Loader::ResultStatus program_nca_status;
 
     std::vector<VirtualDir> partitions;
-    std::shared_ptr<NSP> secure_partition;
-    std::shared_ptr<NCA> program;
     std::vector<std::shared_ptr<NCA>> ncas;
 };
 } // namespace FileSys

src/core/file_sys/content_archive.cpp

@@ -3,17 +3,12 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cstring>
 #include <utility>
-
 #include <boost/optional.hpp>
-
 #include "common/logging/log.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
 #include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_patch.h"
-#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
@@ -69,31 +64,10 @@ struct RomFSSuperblock {
 };
 static_assert(sizeof(RomFSSuperblock) == 0x200, "RomFSSuperblock has incorrect size.");
 
-struct BKTRHeader {
-    u64_le offset;
-    u64_le size;
-    u32_le magic;
-    INSERT_PADDING_BYTES(0x4);
-    u32_le number_entries;
-    INSERT_PADDING_BYTES(0x4);
-};
-static_assert(sizeof(BKTRHeader) == 0x20, "BKTRHeader has incorrect size.");
-
-struct BKTRSuperblock {
-    NCASectionHeaderBlock header_block;
-    IVFCHeader ivfc;
-    INSERT_PADDING_BYTES(0x18);
-    BKTRHeader relocation;
-    BKTRHeader subsection;
-    INSERT_PADDING_BYTES(0xC0);
-};
-static_assert(sizeof(BKTRSuperblock) == 0x200, "BKTRSuperblock has incorrect size.");
-
 union NCASectionHeader {
     NCASectionRaw raw;
     PFS0Superblock pfs0;
     RomFSSuperblock romfs;
-    BKTRSuperblock bktr;
 };
 static_assert(sizeof(NCASectionHeader) == 0x200, "NCASectionHeader has incorrect size.");
 
@@ -126,7 +100,7 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
     Core::Crypto::Key128 out;
     if (type == NCASectionCryptoType::XTS)
         std::copy(key_area.begin(), key_area.begin() + 0x10, out.begin());
-    else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR)
+    else if (type == NCASectionCryptoType::CTR)
         std::copy(key_area.begin() + 0x20, key_area.begin() + 0x30, out.begin());
     else
         LOG_CRITICAL(Crypto, "Called GetKeyAreaKey on invalid NCASectionCryptoType type={:02X}",
@@ -176,9 +150,6 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
         LOG_DEBUG(Crypto, "called with mode=NONE");
         return in;
     case NCASectionCryptoType::CTR:
-    // During normal BKTR decryption, this entire function is skipped. This is for the metadata,
-    // which uses the same CTR as usual.
-    case NCASectionCryptoType::BKTR:
         LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
             boost::optional<Core::Crypto::Key128> key = boost::none;
@@ -207,7 +178,7 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
             return std::static_pointer_cast<VfsFile>(out);
         }
     case NCASectionCryptoType::XTS:
-        // TODO(DarkLordZach): Find a test case for XTS-encrypted NCAs
+        // TODO(DarkLordZach): Implement XTSEncryptionLayer.
     default:
         LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
                   static_cast<u8>(s_header.raw.header.crypto_type));
@@ -215,9 +186,7 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
     }
 }
 
-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) {
+NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
     status = Loader::ResultStatus::Success;
 
     if (file == nullptr) {
@@ -289,24 +258,21 @@ NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_off
         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 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 size_t romfs_offset = base_offset + ivfc_offset;
+            const size_t romfs_offset =
+                header.section_tables[i].media_offset * MEDIA_OFFSET_MULTIPLIER +
+                section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
             const 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) {
+            auto dec =
+                Decrypt(section, std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset),
+                        romfs_offset);
+            if (dec != nullptr) {
+                files.push_back(std::move(dec));
+                romfs = files.back();
+            } else {
                 if (status != Loader::ResultStatus::Success)
                     return;
                 if (has_rights_id)
@@ -315,117 +281,6 @@ NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_off
                     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) +
@@ -441,12 +296,6 @@ NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_off
                     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)
@@ -492,15 +341,11 @@ NCAContentType NCA::GetType() const {
 }
 
 u64 NCA::GetTitleId() const {
-    if (is_update || status == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS)
-        return header.title_id | 0x800;
+    if (status != Loader::ResultStatus::Success)
+        return {};
     return header.title_id;
 }
 
-bool NCA::IsUpdate() const {
-    return is_update;
-}
-
 VirtualFile NCA::GetRomFS() const {
     return romfs;
 }
@@ -513,10 +358,6 @@ VirtualFile NCA::GetBaseFile() const {
     return file;
 }
 
-u64 NCA::GetBaseIVFCOffset() const {
-    return ivfc_offset;
-}
-
 bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
     return false;
 }

src/core/file_sys/content_archive.h

@@ -12,12 +12,10 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "control_metadata.h"
 #include "core/crypto/key_manager.h"
-#include "core/file_sys/vfs.h"
-
-namespace Loader {
-enum class ResultStatus : u16;
-}
+#include "core/file_sys/partition_filesystem.h"
+#include "core/loader/loader.h"
 
 namespace FileSys {
 
@@ -79,8 +77,7 @@ bool IsValidNCA(const NCAHeader& header);
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
 public:
-    explicit NCA(VirtualFile file, VirtualFile bktr_base_romfs = nullptr,
-                 u64 bktr_base_ivfc_offset = 0);
+    explicit NCA(VirtualFile file);
     Loader::ResultStatus GetStatus() const;
 
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
@@ -90,16 +87,12 @@ public:
 
     NCAContentType GetType() const;
     u64 GetTitleId() const;
-    bool IsUpdate() const;
 
     VirtualFile GetRomFS() const;
     VirtualDir GetExeFS() const;
 
     VirtualFile GetBaseFile() const;
 
-    // Returns the base ivfc offset used in BKTR patching.
-    u64 GetBaseIVFCOffset() const;
-
 protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
@@ -115,8 +108,6 @@ private:
     VirtualFile romfs = nullptr;
     VirtualDir exefs = nullptr;
     VirtualFile file;
-    VirtualFile bktr_base_romfs;
-    u64 ivfc_offset;
 
     NCAHeader header{};
     bool has_rights_id{};
@@ -124,7 +115,6 @@ private:
     Loader::ResultStatus status{};
 
     bool encrypted;
-    bool is_update;
 
     Core::Crypto::KeyManager keys;
 };

src/core/file_sys/control_metadata.cpp

@@ -21,17 +21,7 @@ NACP::NACP(VirtualFile file) : raw(std::make_unique<RawNACP>()) {
 }
 
 const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
-    if (language != Language::Default) {
-        return raw->language_entries.at(static_cast<u8>(language));
-    } else {
-        for (const auto& language_entry : raw->language_entries) {
-            if (!language_entry.GetApplicationName().empty())
-                return language_entry;
-        }
-
-        // Fallback to English
-        return GetLanguageEntry(Language::AmericanEnglish);
-    }
+    return raw->language_entries.at(static_cast<u8>(language));
 }
 
 std::string NACP::GetApplicationName(Language language) const {

src/core/file_sys/control_metadata.h

@@ -8,8 +8,6 @@
 #include <memory>
 #include <string>
 #include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
@@ -62,8 +60,6 @@ enum class Language : u8 {
     Korean = 12,
     Taiwanese = 13,
     Chinese = 14,
-
-    Default = 255,
 };
 
 static constexpr std::array<const char*, 15> LANGUAGE_NAMES = {
@@ -78,9 +74,9 @@ static constexpr std::array<const char*, 15> LANGUAGE_NAMES = {
 class NACP {
 public:
     explicit NACP(VirtualFile file);
-    const LanguageEntry& GetLanguageEntry(Language language = Language::Default) const;
-    std::string GetApplicationName(Language language = Language::Default) const;
-    std::string GetDeveloperName(Language language = Language::Default) const;
+    const LanguageEntry& GetLanguageEntry(Language language = Language::AmericanEnglish) const;
+    std::string GetApplicationName(Language language = Language::AmericanEnglish) const;
+    std::string GetDeveloperName(Language language = Language::AmericanEnglish) const;
     u64 GetTitleId() const;
     std::string GetVersionString() const;
 

src/core/file_sys/nca_metadata.cpp

@@ -3,9 +3,10 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-#include "common/common_types.h"
+#include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "common/swap.h"
+#include "content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 
 namespace FileSys {

src/core/file_sys/nca_metadata.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <cstring>
 #include <memory>
 #include <vector>
 #include "common/common_funcs.h"

src/core/file_sys/nca_patch.cpp

@@ -1,210 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstddef>
-#include <cstring>
-
-#include "common/assert.h"
-#include "core/crypto/aes_util.h"
-#include "core/file_sys/nca_patch.h"
-
-namespace FileSys {
-
-BKTR::BKTR(VirtualFile base_romfs_, VirtualFile bktr_romfs_, RelocationBlock relocation_,
-           std::vector<RelocationBucket> relocation_buckets_, SubsectionBlock subsection_,
-           std::vector<SubsectionBucket> subsection_buckets_, bool is_encrypted_,
-           Core::Crypto::Key128 key_, u64 base_offset_, u64 ivfc_offset_,
-           std::array<u8, 8> section_ctr_)
-    : relocation(relocation_), relocation_buckets(std::move(relocation_buckets_)),
-      subsection(subsection_), subsection_buckets(std::move(subsection_buckets_)),
-      base_romfs(std::move(base_romfs_)), bktr_romfs(std::move(bktr_romfs_)),
-      encrypted(is_encrypted_), key(key_), base_offset(base_offset_), ivfc_offset(ivfc_offset_),
-      section_ctr(section_ctr_) {
-    for (size_t i = 0; i < relocation.number_buckets - 1; ++i) {
-        relocation_buckets[i].entries.push_back({relocation.base_offsets[i + 1], 0, 0});
-    }
-
-    for (size_t i = 0; i < subsection.number_buckets - 1; ++i) {
-        subsection_buckets[i].entries.push_back({subsection_buckets[i + 1].entries[0].address_patch,
-                                                 {0},
-                                                 subsection_buckets[i + 1].entries[0].ctr});
-    }
-
-    relocation_buckets.back().entries.push_back({relocation.size, 0, 0});
-}
-
-BKTR::~BKTR() = default;
-
-size_t BKTR::Read(u8* data, size_t length, size_t offset) const {
-    // Read out of bounds.
-    if (offset >= relocation.size)
-        return 0;
-    const auto relocation = GetRelocationEntry(offset);
-    const auto section_offset = offset - relocation.address_patch + relocation.address_source;
-    const auto bktr_read = relocation.from_patch;
-
-    const auto next_relocation = GetNextRelocationEntry(offset);
-
-    if (offset + length > next_relocation.address_patch) {
-        const u64 partition = next_relocation.address_patch - offset;
-        return Read(data, partition, offset) +
-               Read(data + partition, length - partition, offset + partition);
-    }
-
-    if (!bktr_read) {
-        ASSERT_MSG(section_offset >= ivfc_offset, "Offset calculation negative.");
-        return base_romfs->Read(data, length, section_offset - ivfc_offset);
-    }
-
-    if (!encrypted) {
-        return bktr_romfs->Read(data, length, section_offset);
-    }
-
-    const auto subsection = GetSubsectionEntry(section_offset);
-    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(key, Core::Crypto::Mode::CTR);
-
-    // Calculate AES IV
-    std::vector<u8> iv(16);
-    auto subsection_ctr = subsection.ctr;
-    auto offset_iv = section_offset + base_offset;
-    for (size_t i = 0; i < section_ctr.size(); ++i)
-        iv[i] = section_ctr[0x8 - i - 1];
-    offset_iv >>= 4;
-    for (size_t i = 0; i < sizeof(u64); ++i) {
-        iv[0xF - i] = static_cast<u8>(offset_iv & 0xFF);
-        offset_iv >>= 8;
-    }
-    for (size_t i = 0; i < sizeof(u32); ++i) {
-        iv[0x7 - i] = static_cast<u8>(subsection_ctr & 0xFF);
-        subsection_ctr >>= 8;
-    }
-    cipher.SetIV(iv);
-
-    const auto next_subsection = GetNextSubsectionEntry(section_offset);
-
-    if (section_offset + length > next_subsection.address_patch) {
-        const u64 partition = next_subsection.address_patch - section_offset;
-        return Read(data, partition, offset) +
-               Read(data + partition, length - partition, offset + partition);
-    }
-
-    const auto block_offset = section_offset & 0xF;
-    if (block_offset != 0) {
-        auto block = bktr_romfs->ReadBytes(0x10, section_offset & ~0xF);
-        cipher.Transcode(block.data(), block.size(), block.data(), Core::Crypto::Op::Decrypt);
-        if (length + block_offset < 0x10) {
-            std::memcpy(data, block.data() + block_offset, std::min(length, block.size()));
-            return std::min(length, block.size());
-        }
-
-        const auto read = 0x10 - block_offset;
-        std::memcpy(data, block.data() + block_offset, read);
-        return read + Read(data + read, length - read, offset + read);
-    }
-
-    const auto raw_read = bktr_romfs->Read(data, length, section_offset);
-    cipher.Transcode(data, raw_read, data, Core::Crypto::Op::Decrypt);
-    return raw_read;
-}
-
-template <bool Subsection, typename BlockType, typename BucketType>
-std::pair<size_t, size_t> BKTR::SearchBucketEntry(u64 offset, BlockType block,
-                                                  BucketType buckets) const {
-    if constexpr (Subsection) {
-        const auto last_bucket = buckets[block.number_buckets - 1];
-        if (offset >= last_bucket.entries[last_bucket.number_entries].address_patch)
-            return {block.number_buckets - 1, last_bucket.number_entries};
-    } else {
-        ASSERT_MSG(offset <= block.size, "Offset is out of bounds in BKTR relocation block.");
-    }
-
-    size_t bucket_id = std::count_if(block.base_offsets.begin() + 1,
-                                     block.base_offsets.begin() + block.number_buckets,
-                                     [&offset](u64 base_offset) { return base_offset <= offset; });
-
-    const auto bucket = buckets[bucket_id];
-
-    if (bucket.number_entries == 1)
-        return {bucket_id, 0};
-
-    size_t low = 0;
-    size_t mid = 0;
-    size_t high = bucket.number_entries - 1;
-    while (low <= high) {
-        mid = (low + high) / 2;
-        if (bucket.entries[mid].address_patch > offset) {
-            high = mid - 1;
-        } else {
-            if (mid == bucket.number_entries - 1 ||
-                bucket.entries[mid + 1].address_patch > offset) {
-                return {bucket_id, mid};
-            }
-
-            low = mid + 1;
-        }
-    }
-
-    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
-}
-
-RelocationEntry BKTR::GetRelocationEntry(u64 offset) const {
-    const auto res = SearchBucketEntry<false>(offset, relocation, relocation_buckets);
-    return relocation_buckets[res.first].entries[res.second];
-}
-
-RelocationEntry BKTR::GetNextRelocationEntry(u64 offset) const {
-    const auto res = SearchBucketEntry<false>(offset, relocation, relocation_buckets);
-    const auto bucket = relocation_buckets[res.first];
-    if (res.second + 1 < bucket.entries.size())
-        return bucket.entries[res.second + 1];
-    return relocation_buckets[res.first + 1].entries[0];
-}
-
-SubsectionEntry BKTR::GetSubsectionEntry(u64 offset) const {
-    const auto res = SearchBucketEntry<true>(offset, subsection, subsection_buckets);
-    return subsection_buckets[res.first].entries[res.second];
-}
-
-SubsectionEntry BKTR::GetNextSubsectionEntry(u64 offset) const {
-    const auto res = SearchBucketEntry<true>(offset, subsection, subsection_buckets);
-    const auto bucket = subsection_buckets[res.first];
-    if (res.second + 1 < bucket.entries.size())
-        return bucket.entries[res.second + 1];
-    return subsection_buckets[res.first + 1].entries[0];
-}
-
-std::string BKTR::GetName() const {
-    return base_romfs->GetName();
-}
-
-size_t BKTR::GetSize() const {
-    return relocation.size;
-}
-
-bool BKTR::Resize(size_t new_size) {
-    return false;
-}
-
-std::shared_ptr<VfsDirectory> BKTR::GetContainingDirectory() const {
-    return base_romfs->GetContainingDirectory();
-}
-
-bool BKTR::IsWritable() const {
-    return false;
-}
-
-bool BKTR::IsReadable() const {
-    return true;
-}
-
-size_t BKTR::Write(const u8* data, size_t length, size_t offset) {
-    return 0;
-}
-
-bool BKTR::Rename(std::string_view name) {
-    return base_romfs->Rename(name);
-}
-
-} // namespace FileSys

src/core/file_sys/nca_patch.h

@@ -1,150 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <vector>
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/crypto/key_manager.h"
-
-namespace FileSys {
-
-#pragma pack(push, 1)
-struct RelocationEntry {
-    u64_le address_patch;
-    u64_le address_source;
-    u32 from_patch;
-};
-#pragma pack(pop)
-static_assert(sizeof(RelocationEntry) == 0x14, "RelocationEntry has incorrect size.");
-
-struct RelocationBucketRaw {
-    INSERT_PADDING_BYTES(4);
-    u32_le number_entries;
-    u64_le end_offset;
-    std::array<RelocationEntry, 0x332> relocation_entries;
-    INSERT_PADDING_BYTES(8);
-};
-static_assert(sizeof(RelocationBucketRaw) == 0x4000, "RelocationBucketRaw has incorrect size.");
-
-// Vector version of RelocationBucketRaw
-struct RelocationBucket {
-    u32 number_entries;
-    u64 end_offset;
-    std::vector<RelocationEntry> entries;
-};
-
-struct RelocationBlock {
-    INSERT_PADDING_BYTES(4);
-    u32_le number_buckets;
-    u64_le size;
-    std::array<u64, 0x7FE> base_offsets;
-};
-static_assert(sizeof(RelocationBlock) == 0x4000, "RelocationBlock has incorrect size.");
-
-struct SubsectionEntry {
-    u64_le address_patch;
-    INSERT_PADDING_BYTES(0x4);
-    u32_le ctr;
-};
-static_assert(sizeof(SubsectionEntry) == 0x10, "SubsectionEntry has incorrect size.");
-
-struct SubsectionBucketRaw {
-    INSERT_PADDING_BYTES(4);
-    u32_le number_entries;
-    u64_le end_offset;
-    std::array<SubsectionEntry, 0x3FF> subsection_entries;
-};
-static_assert(sizeof(SubsectionBucketRaw) == 0x4000, "SubsectionBucketRaw has incorrect size.");
-
-// Vector version of SubsectionBucketRaw
-struct SubsectionBucket {
-    u32 number_entries;
-    u64 end_offset;
-    std::vector<SubsectionEntry> entries;
-};
-
-struct SubsectionBlock {
-    INSERT_PADDING_BYTES(4);
-    u32_le number_buckets;
-    u64_le size;
-    std::array<u64, 0x7FE> base_offsets;
-};
-static_assert(sizeof(SubsectionBlock) == 0x4000, "SubsectionBlock has incorrect size.");
-
-inline RelocationBucket ConvertRelocationBucketRaw(RelocationBucketRaw raw) {
-    return {raw.number_entries,
-            raw.end_offset,
-            {raw.relocation_entries.begin(), raw.relocation_entries.begin() + raw.number_entries}};
-}
-
-inline SubsectionBucket ConvertSubsectionBucketRaw(SubsectionBucketRaw raw) {
-    return {raw.number_entries,
-            raw.end_offset,
-            {raw.subsection_entries.begin(), raw.subsection_entries.begin() + raw.number_entries}};
-}
-
-class BKTR : public VfsFile {
-public:
-    BKTR(VirtualFile base_romfs, VirtualFile bktr_romfs, RelocationBlock relocation,
-         std::vector<RelocationBucket> relocation_buckets, SubsectionBlock subsection,
-         std::vector<SubsectionBucket> subsection_buckets, bool is_encrypted,
-         Core::Crypto::Key128 key, u64 base_offset, u64 ivfc_offset, std::array<u8, 8> section_ctr);
-    ~BKTR() override;
-
-    size_t Read(u8* data, size_t length, size_t offset) const override;
-
-    std::string GetName() const override;
-
-    size_t GetSize() const override;
-
-    bool Resize(size_t new_size) override;
-
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
-
-    bool IsWritable() const override;
-
-    bool IsReadable() const override;
-
-    size_t Write(const u8* data, size_t length, size_t offset) override;
-
-    bool Rename(std::string_view name) override;
-
-private:
-    template <bool Subsection, typename BlockType, typename BucketType>
-    std::pair<size_t, size_t> SearchBucketEntry(u64 offset, BlockType block,
-                                                BucketType buckets) const;
-
-    RelocationEntry GetRelocationEntry(u64 offset) const;
-    RelocationEntry GetNextRelocationEntry(u64 offset) const;
-
-    SubsectionEntry GetSubsectionEntry(u64 offset) const;
-    SubsectionEntry GetNextSubsectionEntry(u64 offset) const;
-
-    RelocationBlock relocation;
-    std::vector<RelocationBucket> relocation_buckets;
-    SubsectionBlock subsection;
-    std::vector<SubsectionBucket> subsection_buckets;
-
-    // Should be the raw base romfs, decrypted.
-    VirtualFile base_romfs;
-    // Should be the raw BKTR romfs, (located at media_offset with size media_size).
-    VirtualFile bktr_romfs;
-
-    bool encrypted;
-    Core::Crypto::Key128 key;
-
-    // Base offset into NCA, used for IV calculation.
-    u64 base_offset;
-    // Distance between IVFC start and RomFS start, used for base reads
-    u64 ivfc_offset;
-    std::array<u8, 8> section_ctr;
-};
-
-} // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -1,157 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include <cstddef>
-
-#include "common/logging/log.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/control_metadata.h"
-#include "core/file_sys/patch_manager.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/romfs.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/loader/loader.h"
-
-namespace FileSys {
-
-constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
-
-std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
-    std::array<u8, sizeof(u32)> bytes{};
-    bytes[0] = version % SINGLE_BYTE_MODULUS;
-    for (size_t i = 1; i < bytes.size(); ++i) {
-        version /= SINGLE_BYTE_MODULUS;
-        bytes[i] = version % SINGLE_BYTE_MODULUS;
-    }
-
-    if (format == TitleVersionFormat::FourElements)
-        return fmt::format("v{}.{}.{}.{}", bytes[3], bytes[2], bytes[1], bytes[0]);
-    return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
-}
-
-constexpr std::array<const char*, 1> PATCH_TYPE_NAMES{
-    "Update",
-};
-
-std::string FormatPatchTypeName(PatchType type) {
-    return PATCH_TYPE_NAMES.at(static_cast<size_t>(type));
-}
-
-PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
-
-VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
-    LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);
-
-    if (exefs == nullptr)
-        return exefs;
-
-    const auto installed = Service::FileSystem::GetUnionContents();
-
-    // Game Updates
-    const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed->GetEntry(update_tid, ContentRecordType::Program);
-    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;
-}
-
-VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset,
-                                     ContentRecordType type) const {
-    LOG_INFO(Loader, "Patching RomFS for title_id={:016X}, type={:02X}", title_id,
-             static_cast<u8>(type));
-
-    if (romfs == nullptr)
-        return romfs;
-
-    const auto installed = Service::FileSystem::GetUnionContents();
-
-    // Game Updates
-    const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed->GetEntryRaw(update_tid, type);
-    if (update != nullptr) {
-        const auto new_nca = std::make_shared<NCA>(update, romfs, ivfc_offset);
-        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
-            new_nca->GetRomFS() != nullptr) {
-            LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
-            romfs = new_nca->GetRomFS();
-        }
-    }
-
-    return romfs;
-}
-
-std::map<PatchType, std::string> PatchManager::GetPatchVersionNames() const {
-    std::map<PatchType, std::string> out;
-    const auto installed = Service::FileSystem::GetUnionContents();
-
-    const auto update_tid = GetUpdateTitleID(title_id);
-    PatchManager update{update_tid};
-    auto [nacp, discard_icon_file] = update.GetControlMetadata();
-
-    if (nacp != nullptr) {
-        out[PatchType::Update] = nacp->GetVersionString();
-    } else {
-        if (installed->HasEntry(update_tid, ContentRecordType::Program)) {
-            const auto meta_ver = installed->GetEntryVersion(update_tid);
-            if (meta_ver == boost::none || meta_ver.get() == 0) {
-                out[PatchType::Update] = "";
-            } else {
-                out[PatchType::Update] =
-                    FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements);
-            }
-        }
-    }
-
-    return out;
-}
-
-std::pair<std::shared_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
-    const auto& installed{Service::FileSystem::GetUnionContents()};
-
-    const auto base_control_nca = installed->GetEntry(title_id, ContentRecordType::Control);
-    if (base_control_nca == nullptr)
-        return {};
-
-    return ParseControlNCA(base_control_nca);
-}
-
-std::pair<std::shared_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(
-    const std::shared_ptr<NCA>& nca) const {
-    const auto base_romfs = nca->GetRomFS();
-    if (base_romfs == nullptr)
-        return {};
-
-    const auto romfs = PatchRomFS(base_romfs, nca->GetBaseIVFCOffset(), ContentRecordType::Control);
-    if (romfs == nullptr)
-        return {};
-
-    const auto extracted = ExtractRomFS(romfs);
-    if (extracted == nullptr)
-        return {};
-
-    auto nacp_file = extracted->GetFile("control.nacp");
-    if (nacp_file == nullptr)
-        nacp_file = extracted->GetFile("Control.nacp");
-
-    const auto nacp = nacp_file == nullptr ? nullptr : std::make_shared<NACP>(nacp_file);
-
-    VirtualFile icon_file;
-    for (const auto& language : FileSys::LANGUAGE_NAMES) {
-        icon_file = extracted->GetFile("icon_" + std::string(language) + ".dat");
-        if (icon_file != nullptr)
-            break;
-    }
-
-    return {nacp, icon_file};
-}
-} // namespace FileSys

src/core/file_sys/patch_manager.h

@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-
-class NCA;
-class NACP;
-
-enum class TitleVersionFormat : u8 {
-    ThreeElements, ///< vX.Y.Z
-    FourElements,  ///< vX.Y.Z.W
-};
-
-std::string FormatTitleVersion(u32 version,
-                               TitleVersionFormat format = TitleVersionFormat::ThreeElements);
-
-enum class PatchType {
-    Update,
-};
-
-std::string FormatPatchTypeName(PatchType type);
-
-// A centralized class to manage patches to games.
-class PatchManager {
-public:
-    explicit PatchManager(u64 title_id);
-
-    // Currently tracked ExeFS patches:
-    // - Game Updates
-    VirtualDir PatchExeFS(VirtualDir exefs) const;
-
-    // Currently tracked RomFS patches:
-    // - Game Updates
-    VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
-                           ContentRecordType type = ContentRecordType::Program) const;
-
-    // Returns a vector of pairs between patch names and patch versions.
-    // i.e. Update v80 will return {Update, 80}
-    std::map<PatchType, std::string> GetPatchVersionNames() const;
-
-    // Given title_id of the program, attempts to get the control data of the update and parse it,
-    // falling back to the base control data.
-    std::pair<std::shared_ptr<NACP>, VirtualFile> GetControlMetadata() const;
-
-    // Version of GetControlMetadata that takes an arbitrary NCA
-    std::pair<std::shared_ptr<NACP>, VirtualFile> ParseControlNCA(
-        const std::shared_ptr<NCA>& nca) const;
-
-private:
-    u64 title_id;
-};
-
-} // namespace FileSys

src/core/file_sys/program_metadata.cpp

@@ -2,10 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstddef>
-#include <cstring>
-#include <vector>
-
+#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/loader/loader.h"

src/core/file_sys/program_metadata.h

@@ -5,10 +5,12 @@
 #pragma once
 
 #include <array>
+#include <string>
+#include <vector>
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/file_sys/vfs.h"
+#include "partition_filesystem.h"
 
 namespace Loader {
 enum class ResultStatus : u16;

src/core/file_sys/registered_cache.cpp

@@ -5,17 +5,13 @@
 #include <regex>
 #include <mbedtls/sha256.h>
 #include "common/assert.h"
-#include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "core/crypto/key_manager.h"
+#include "core/crypto/encryption_layer.h"
 #include "core/file_sys/card_image.h"
-#include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/registered_cache.h"
-#include "core/file_sys/submission_package.h"
 #include "core/file_sys/vfs_concat.h"
-#include "core/loader/loader.h"
 
 namespace FileSys {
 std::string RegisteredCacheEntry::DebugInfo() const {
@@ -220,11 +216,11 @@ void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {
 
         const auto section0 = nca->GetSubdirectories()[0];
 
-        for (const auto& section0_file : section0->GetFiles()) {
-            if (section0_file->GetExtension() != "cnmt")
+        for (const auto& file : section0->GetFiles()) {
+            if (file->GetExtension() != "cnmt")
                 continue;
 
-            meta.insert_or_assign(nca->GetTitleId(), CNMT(section0_file));
+            meta.insert_or_assign(nca->GetTitleId(), CNMT(file));
             meta_id.insert_or_assign(nca->GetTitleId(), id);
             break;
         }
@@ -258,8 +254,6 @@ RegisteredCache::RegisteredCache(VirtualDir dir_, RegisteredCacheParsingFunction
     Refresh();
 }
 
-RegisteredCache::~RegisteredCache() = default;
-
 bool RegisteredCache::HasEntry(u64 title_id, ContentRecordType type) const {
     return GetEntryRaw(title_id, type) != nullptr;
 }
@@ -268,30 +262,6 @@ bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {
     return GetEntryRaw(entry) != nullptr;
 }
 
-VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
-    const auto id = GetNcaIDFromMetadata(title_id, type);
-    if (id == boost::none)
-        return nullptr;
-
-    return GetFileAtID(id.get());
-}
-
-VirtualFile RegisteredCache::GetEntryUnparsed(RegisteredCacheEntry entry) const {
-    return GetEntryUnparsed(entry.title_id, entry.type);
-}
-
-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();
-
-    const auto yuzu_meta_iter = yuzu_meta.find(title_id);
-    if (yuzu_meta_iter != yuzu_meta.end())
-        return yuzu_meta_iter->second.GetTitleVersion();
-
-    return boost::none;
-}
-
 VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) const {
     const auto id = GetNcaIDFromMetadata(title_id, type);
     if (id == boost::none)
@@ -371,21 +341,17 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
     return out;
 }
 
-static std::shared_ptr<NCA> GetNCAFromNSPForID(std::shared_ptr<NSP> nsp, const NcaID& id) {
-    const auto file = nsp->GetFile(fmt::format("{}.nca", Common::HexArrayToString(id, false)));
-    if (file == nullptr)
-        return nullptr;
-    return std::make_shared<NCA>(file);
+static std::shared_ptr<NCA> GetNCAFromXCIForID(std::shared_ptr<XCI> xci, const NcaID& id) {
+    const auto filename = fmt::format("{}.nca", Common::HexArrayToString(id, false));
+    const auto iter =
+        std::find_if(xci->GetNCAs().begin(), xci->GetNCAs().end(),
+                     [&filename](std::shared_ptr<NCA> nca) { return nca->GetName() == filename; });
+    return iter == xci->GetNCAs().end() ? nullptr : *iter;
 }
 
 InstallResult RegisteredCache::InstallEntry(std::shared_ptr<XCI> xci, bool overwrite_if_exists,
                                             const VfsCopyFunction& copy) {
-    return InstallEntry(xci->GetSecurePartitionNSP(), overwrite_if_exists, copy);
-}
-
-InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NSP> nsp, bool overwrite_if_exists,
-                                            const VfsCopyFunction& copy) {
-    const auto& ncas = nsp->GetNCAsCollapsed();
+    const auto& ncas = xci->GetNCAs();
     const auto& meta_iter = std::find_if(ncas.begin(), ncas.end(), [](std::shared_ptr<NCA> nca) {
         return nca->GetType() == NCAContentType::Meta;
     });
@@ -409,7 +375,7 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<NSP> nsp, bool overw
     const auto cnmt_file = section0->GetFiles()[0];
     const CNMT cnmt(cnmt_file);
     for (const auto& record : cnmt.GetContentRecords()) {
-        const auto nca = GetNCAFromNSPForID(nsp, record.nca_id);
+        const auto nca = GetNCAFromXCIForID(xci, record.nca_id);
         if (nca == nullptr)
             return InstallResult::ErrorCopyFailed;
         const auto res2 = RawInstallNCA(nca, copy, overwrite_if_exists, record.nca_id);
@@ -510,107 +476,4 @@ bool RegisteredCache::RawInstallYuzuMeta(const CNMT& cnmt) {
                                    kv.second.GetTitleID() == cnmt.GetTitleID();
                         }) != yuzu_meta.end();
 }
-
-RegisteredCacheUnion::RegisteredCacheUnion(std::vector<std::shared_ptr<RegisteredCache>> caches)
-    : caches(std::move(caches)) {}
-
-void RegisteredCacheUnion::Refresh() {
-    for (const auto& c : caches)
-        c->Refresh();
-}
-
-bool RegisteredCacheUnion::HasEntry(u64 title_id, ContentRecordType type) const {
-    return std::any_of(caches.begin(), caches.end(), [title_id, type](const auto& cache) {
-        return cache->HasEntry(title_id, type);
-    });
-}
-
-bool RegisteredCacheUnion::HasEntry(RegisteredCacheEntry entry) const {
-    return HasEntry(entry.title_id, entry.type);
-}
-
-boost::optional<u32> RegisteredCacheUnion::GetEntryVersion(u64 title_id) const {
-    for (const auto& c : caches) {
-        const auto res = c->GetEntryVersion(title_id);
-        if (res != boost::none)
-            return res;
-    }
-
-    return boost::none;
-}
-
-VirtualFile RegisteredCacheUnion::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
-    for (const auto& c : caches) {
-        const auto res = c->GetEntryUnparsed(title_id, type);
-        if (res != nullptr)
-            return res;
-    }
-
-    return nullptr;
-}
-
-VirtualFile RegisteredCacheUnion::GetEntryUnparsed(RegisteredCacheEntry entry) const {
-    return GetEntryUnparsed(entry.title_id, entry.type);
-}
-
-VirtualFile RegisteredCacheUnion::GetEntryRaw(u64 title_id, ContentRecordType type) const {
-    for (const auto& c : caches) {
-        const auto res = c->GetEntryRaw(title_id, type);
-        if (res != nullptr)
-            return res;
-    }
-
-    return nullptr;
-}
-
-VirtualFile RegisteredCacheUnion::GetEntryRaw(RegisteredCacheEntry entry) const {
-    return GetEntryRaw(entry.title_id, entry.type);
-}
-
-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_shared<NCA>(raw);
-}
-
-std::shared_ptr<NCA> RegisteredCacheUnion::GetEntry(RegisteredCacheEntry entry) const {
-    return GetEntry(entry.title_id, entry.type);
-}
-
-std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
-    std::vector<RegisteredCacheEntry> out;
-    for (const auto& c : caches) {
-        c->IterateAllMetadata<RegisteredCacheEntry>(
-            out,
-            [](const CNMT& c, const ContentRecord& r) {
-                return RegisteredCacheEntry{c.GetTitleID(), r.type};
-            },
-            [](const CNMT& c, const ContentRecord& r) { return true; });
-    }
-    return out;
-}
-
-std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
-    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>(
-            out,
-            [](const CNMT& c, const ContentRecord& r) {
-                return RegisteredCacheEntry{c.GetTitleID(), r.type};
-            },
-            [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
-                if (title_type != boost::none && title_type.get() != c.GetType())
-                    return false;
-                if (record_type != boost::none && record_type.get() != r.type)
-                    return false;
-                if (title_id != boost::none && title_id.get() != c.GetTitleID())
-                    return false;
-                return true;
-            });
-    }
-    return out;
-}
 } // namespace FileSys

src/core/file_sys/registered_cache.h

@@ -11,19 +11,15 @@
 #include <string>
 #include <vector>
 #include <boost/container/flat_map.hpp>
+#include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "content_archive.h"
+#include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
-class CNMT;
-class NCA;
-class NSP;
 class XCI;
-
-enum class ContentRecordType : u8;
-enum class TitleType : u8;
-
-struct ContentRecord;
+class CNMT;
 
 using NcaID = std::array<u8, 0x10>;
 using RegisteredCacheParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
@@ -43,10 +39,6 @@ struct RegisteredCacheEntry {
     std::string DebugInfo() const;
 };
 
-constexpr u64 GetUpdateTitleID(u64 base_title_id) {
-    return base_title_id | 0x800;
-}
-
 // boost flat_map requires operator< for O(log(n)) lookups.
 bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
 
@@ -64,8 +56,6 @@ bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs)
  * 4GB splitting can be ignored.)
  */
 class RegisteredCache {
-    friend class RegisteredCacheUnion;
-
 public:
     // Parsing function defines the conversion from raw file to NCA. If there are other steps
     // besides creating the NCA from the file (e.g. NAX0 on SD Card), that should go in a custom
@@ -73,18 +63,12 @@ public:
     explicit RegisteredCache(VirtualDir dir,
                              RegisteredCacheParsingFunction parsing_function =
                                  [](const VirtualFile& file, const NcaID& id) { return file; });
-    ~RegisteredCache();
 
     void Refresh();
 
     bool HasEntry(u64 title_id, ContentRecordType type) const;
     bool HasEntry(RegisteredCacheEntry entry) const;
 
-    boost::optional<u32> GetEntryVersion(u64 title_id) const;
-
-    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
-
     VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
     VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
 
@@ -98,12 +82,10 @@ public:
         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.
+    // Raw copies all the ncas from the xci to the csache. Does some quick checks to make sure there
+    // is a meta NCA and all of them are accessible.
     InstallResult InstallEntry(std::shared_ptr<XCI> xci, bool overwrite_if_exists = false,
                                const VfsCopyFunction& copy = &VfsRawCopy);
-    InstallResult InstallEntry(std::shared_ptr<NSP> nsp, bool overwrite_if_exists = false,
-                               const VfsCopyFunction& copy = &VfsRawCopy);
 
     // Due to the fact that we must use Meta-type NCAs to determine the existance of files, this
     // poses quite a challenge. Instead of creating a new meta NCA for this file, yuzu will create a
@@ -139,36 +121,4 @@ private:
     boost::container::flat_map<u64, CNMT> yuzu_meta;
 };
 
-// Combines multiple RegisteredCaches (i.e. SysNAND, UserNAND, SDMC) into one interface.
-class RegisteredCacheUnion {
-public:
-    explicit RegisteredCacheUnion(std::vector<std::shared_ptr<RegisteredCache>> caches);
-
-    void Refresh();
-
-    bool HasEntry(u64 title_id, ContentRecordType type) const;
-    bool HasEntry(RegisteredCacheEntry entry) const;
-
-    boost::optional<u32> GetEntryVersion(u64 title_id) const;
-
-    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
-
-    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
-
-    std::shared_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
-    std::shared_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
-
-    std::vector<RegisteredCacheEntry> ListEntries() const;
-    // If a parameter is not boost::none, it will be filtered for from all entries.
-    std::vector<RegisteredCacheEntry> ListEntriesFilter(
-        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<std::shared_ptr<RegisteredCache>> caches;
-};
-
 } // namespace FileSys

src/core/file_sys/romfs.h

@@ -6,7 +6,6 @@
 
 #include <array>
 #include "common/common_funcs.h"
-#include "common/common_types.h"
 #include "common/swap.h"
 #include "core/file_sys/vfs.h"
 

src/core/file_sys/romfs_factory.cpp

@@ -2,14 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
 #include <memory>
-#include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/hle/kernel/process.h"
@@ -23,17 +20,10 @@ RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     if (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
     }
-
-    updatable = app_loader.IsRomFSUpdatable();
-    ivfc_offset = app_loader.ReadRomFSIVFCOffset();
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
-    if (!updatable)
-        return MakeResult<VirtualFile>(file);
-
-    const PatchManager patch_manager(Core::CurrentProcess()->program_id);
-    return MakeResult<VirtualFile>(patch_manager.PatchRomFS(file, ivfc_offset));
+    return MakeResult<VirtualFile>(file);
 }
 
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {

src/core/file_sys/romfs_factory.h

@@ -36,8 +36,6 @@ public:
 
 private:
     VirtualFile file;
-    bool updatable;
-    u64 ivfc_offset;
 };
 
 } // namespace FileSys

src/core/file_sys/savedata_factory.cpp

@@ -3,12 +3,10 @@
 // Refer to the license.txt file included.
 
 #include <memory>
-#include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
-#include "core/file_sys/vfs.h"
 #include "core/hle/kernel/process.h"
 
 namespace FileSys {
@@ -75,7 +73,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescr
 }
 
 std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
-                                         u128 user_id, u64 save_id) {
+                                         u128 user_id, u64 save_id) const {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
     // be interpreted as the title id of the current process.
     if (type == SaveDataType::SaveData && title_id == 0)

src/core/file_sys/savedata_factory.h

@@ -6,10 +6,8 @@
 
 #include <memory>
 #include <string>
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
@@ -51,11 +49,11 @@ public:
 
     ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
 
-    static std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
-                                   u128 user_id, u64 save_id);
-
 private:
     VirtualDir dir;
+
+    std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id,
+                            u64 save_id) const;
 };
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.cpp

@@ -3,27 +3,14 @@
 // Refer to the license.txt file included.
 
 #include <memory>
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/sdmc_factory.h"
-#include "core/file_sys/xts_archive.h"
 
 namespace FileSys {
 
-SDMCFactory::SDMCFactory(VirtualDir dir_)
-    : dir(std::move(dir_)), contents(std::make_shared<RegisteredCache>(
-                                GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/registered"),
-                                [](const VirtualFile& file, const NcaID& id) {
-                                    return std::make_shared<NAX>(file, id)->GetDecrypted();
-                                })) {}
-
-SDMCFactory::~SDMCFactory() = default;
+SDMCFactory::SDMCFactory(VirtualDir dir) : dir(std::move(dir)) {}
 
 ResultVal<VirtualDir> SDMCFactory::Open() {
     return MakeResult<VirtualDir>(dir);
 }
 
-std::shared_ptr<RegisteredCache> SDMCFactory::GetSDMCContents() const {
-    return contents;
-}
-
 } // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -4,27 +4,20 @@
 
 #pragma once
 
-#include <memory>
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
 
-class RegisteredCache;
-
 /// File system interface to the SDCard archive
 class SDMCFactory {
 public:
     explicit SDMCFactory(VirtualDir dir);
-    ~SDMCFactory();
 
     ResultVal<VirtualDir> Open();
-    std::shared_ptr<RegisteredCache> GetSDMCContents() const;
 
 private:
     VirtualDir dir;
-
-    std::shared_ptr<RegisteredCache> contents;
 };
 
 } // namespace FileSys

src/core/file_sys/submission_package.cpp

@@ -1,245 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstring>
-#include <string_view>
-
-#include <fmt/ostream.h>
-
-#include "common/hex_util.h"
-#include "common/logging/log.h"
-#include "core/crypto/key_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/submission_package.h"
-#include "core/loader/loader.h"
-
-namespace FileSys {
-NSP::NSP(VirtualFile file_)
-    : file(std::move(file_)), status{Loader::ResultStatus::Success},
-      pfs(std::make_shared<PartitionFilesystem>(file)) {
-    if (pfs->GetStatus() != Loader::ResultStatus::Success) {
-        status = pfs->GetStatus();
-        return;
-    }
-
-    if (IsDirectoryExeFS(pfs)) {
-        extracted = true;
-        exefs = pfs;
-
-        const auto& files = pfs->GetFiles();
-        const auto romfs_iter =
-            std::find_if(files.begin(), files.end(), [](const FileSys::VirtualFile& file) {
-                return file->GetName().find(".romfs") != std::string::npos;
-            });
-        if (romfs_iter != files.end())
-            romfs = *romfs_iter;
-        return;
-    }
-
-    extracted = false;
-    const auto files = pfs->GetFiles();
-
-    Core::Crypto::KeyManager keys;
-    for (const auto& ticket_file : files) {
-        if (ticket_file->GetExtension() == "tik") {
-            if (ticket_file == nullptr ||
-                ticket_file->GetSize() <
-                    Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET + sizeof(Core::Crypto::Key128)) {
-                continue;
-            }
-
-            Core::Crypto::Key128 key{};
-            ticket_file->Read(key.data(), key.size(), Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET);
-            std::string_view name_only(ticket_file->GetName());
-            name_only.remove_suffix(4);
-            const auto rights_id_raw = Common::HexStringToArray<16>(name_only);
-            u128 rights_id;
-            std::memcpy(rights_id.data(), rights_id_raw.data(), sizeof(u128));
-            keys.SetKey(Core::Crypto::S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
-        }
-    }
-
-    for (const auto& outer_file : files) {
-        if (outer_file->GetName().substr(outer_file->GetName().size() - 9) == ".cnmt.nca") {
-            const auto nca = std::make_shared<NCA>(outer_file);
-            if (nca->GetStatus() != Loader::ResultStatus::Success) {
-                program_status[nca->GetTitleId()] = nca->GetStatus();
-                continue;
-            }
-
-            const auto section0 = nca->GetSubdirectories()[0];
-
-            for (const auto& inner_file : section0->GetFiles()) {
-                if (inner_file->GetExtension() != "cnmt")
-                    continue;
-
-                const CNMT cnmt(inner_file);
-                auto& ncas_title = ncas[cnmt.GetTitleID()];
-
-                ncas_title[ContentRecordType::Meta] = nca;
-                for (const auto& rec : cnmt.GetContentRecords()) {
-                    const auto id_string = Common::HexArrayToString(rec.nca_id, false);
-                    const auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
-                    if (next_file == nullptr) {
-                        LOG_WARNING(Service_FS,
-                                    "NCA with ID {}.nca is listed in content metadata, but cannot "
-                                    "be found in PFS. NSP appears to be corrupted.",
-                                    id_string);
-                        continue;
-                    }
-
-                    auto next_nca = std::make_shared<NCA>(next_file);
-                    if (next_nca->GetType() == NCAContentType::Program)
-                        program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
-                    if (next_nca->GetStatus() == Loader::ResultStatus::Success)
-                        ncas_title[rec.type] = std::move(next_nca);
-                }
-
-                break;
-            }
-        }
-    }
-}
-
-NSP::~NSP() = default;
-
-Loader::ResultStatus NSP::GetStatus() const {
-    return status;
-}
-
-Loader::ResultStatus NSP::GetProgramStatus(u64 title_id) const {
-    const auto iter = program_status.find(title_id);
-    if (iter == program_status.end())
-        return Loader::ResultStatus::ErrorNSPMissingProgramNCA;
-    return iter->second;
-}
-
-u64 NSP::GetFirstTitleID() const {
-    if (program_status.empty())
-        return 0;
-    return program_status.begin()->first;
-}
-
-u64 NSP::GetProgramTitleID() const {
-    const auto out = GetFirstTitleID();
-    if ((out & 0x800) == 0)
-        return out;
-
-    const auto ids = GetTitleIDs();
-    const auto iter =
-        std::find_if(ids.begin(), ids.end(), [](u64 tid) { return (tid & 0x800) == 0; });
-    return iter == ids.end() ? out : *iter;
-}
-
-std::vector<u64> NSP::GetTitleIDs() const {
-    std::vector<u64> out;
-    out.reserve(ncas.size());
-    for (const auto& kv : ncas)
-        out.push_back(kv.first);
-    return out;
-}
-
-bool NSP::IsExtractedType() const {
-    return extracted;
-}
-
-VirtualFile NSP::GetRomFS() const {
-    return romfs;
-}
-
-VirtualDir NSP::GetExeFS() const {
-    return exefs;
-}
-
-std::vector<std::shared_ptr<NCA>> NSP::GetNCAsCollapsed() const {
-    if (extracted)
-        LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
-    std::vector<std::shared_ptr<NCA>> out;
-    for (const auto& map : ncas) {
-        for (const auto& inner_map : map.second)
-            out.push_back(inner_map.second);
-    }
-    return out;
-}
-
-std::multimap<u64, std::shared_ptr<NCA>> NSP::GetNCAsByTitleID() const {
-    if (extracted)
-        LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
-    std::multimap<u64, std::shared_ptr<NCA>> out;
-    for (const auto& map : ncas) {
-        for (const auto& inner_map : map.second)
-            out.emplace(map.first, inner_map.second);
-    }
-    return out;
-}
-
-std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> NSP::GetNCAs() const {
-    return ncas;
-}
-
-std::shared_ptr<NCA> NSP::GetNCA(u64 title_id, ContentRecordType type) const {
-    if (extracted)
-        LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
-
-    const auto title_id_iter = ncas.find(title_id);
-    if (title_id_iter == ncas.end())
-        return nullptr;
-
-    const auto type_iter = title_id_iter->second.find(type);
-    if (type_iter == title_id_iter->second.end())
-        return nullptr;
-
-    return type_iter->second;
-}
-
-VirtualFile NSP::GetNCAFile(u64 title_id, ContentRecordType type) const {
-    if (extracted)
-        LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
-    const auto nca = GetNCA(title_id, type);
-    if (nca != nullptr)
-        return nca->GetBaseFile();
-    return nullptr;
-}
-
-std::vector<Core::Crypto::Key128> NSP::GetTitlekey() const {
-    if (extracted)
-        LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
-    std::vector<Core::Crypto::Key128> out;
-    for (const auto& ticket_file : ticket_files) {
-        if (ticket_file == nullptr ||
-            ticket_file->GetSize() <
-                Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET + sizeof(Core::Crypto::Key128)) {
-            continue;
-        }
-
-        out.emplace_back();
-        ticket_file->Read(out.back().data(), out.back().size(),
-                          Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET);
-    }
-    return out;
-}
-
-std::vector<VirtualFile> NSP::GetFiles() const {
-    return pfs->GetFiles();
-}
-
-std::vector<VirtualDir> NSP::GetSubdirectories() const {
-    return pfs->GetSubdirectories();
-}
-
-std::string NSP::GetName() const {
-    return file->GetName();
-}
-
-VirtualDir NSP::GetParentDirectory() const {
-    return file->GetContainingDirectory();
-}
-
-bool NSP::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    return false;
-}
-} // namespace FileSys

src/core/file_sys/submission_package.h

@@ -1,76 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include <memory>
-#include <vector>
-#include "common/common_types.h"
-#include "core/file_sys/vfs.h"
-
-namespace Loader {
-enum class ResultStatus : u16;
-}
-
-namespace FileSys {
-
-class NCA;
-class PartitionFilesystem;
-
-enum class ContentRecordType : u8;
-
-class NSP : public ReadOnlyVfsDirectory {
-public:
-    explicit NSP(VirtualFile file);
-    ~NSP();
-
-    Loader::ResultStatus GetStatus() const;
-    Loader::ResultStatus GetProgramStatus(u64 title_id) const;
-    // Should only be used when one title id can be assured.
-    u64 GetFirstTitleID() const;
-    u64 GetProgramTitleID() const;
-    std::vector<u64> GetTitleIDs() const;
-
-    bool IsExtractedType() const;
-
-    // Common (Can be safely called on both types)
-    VirtualFile GetRomFS() const;
-    VirtualDir GetExeFS() const;
-
-    // Type 0 Only (Collection of NCAs + Certificate + Ticket + Meta XML)
-    std::vector<std::shared_ptr<NCA>> GetNCAsCollapsed() const;
-    std::multimap<u64, std::shared_ptr<NCA>> GetNCAsByTitleID() const;
-    std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> GetNCAs() const;
-    std::shared_ptr<NCA> GetNCA(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetNCAFile(u64 title_id, ContentRecordType type) const;
-    std::vector<Core::Crypto::Key128> GetTitlekey() const;
-
-    std::vector<VirtualFile> GetFiles() const override;
-
-    std::vector<VirtualDir> GetSubdirectories() const override;
-
-    std::string GetName() const override;
-
-    VirtualDir GetParentDirectory() const override;
-
-protected:
-    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
-
-private:
-    VirtualFile file;
-
-    bool extracted;
-    Loader::ResultStatus status;
-    std::map<u64, Loader::ResultStatus> program_status;
-
-    std::shared_ptr<PartitionFilesystem> pfs;
-    // Map title id -> {map type -> NCA}
-    std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> ncas;
-    std::vector<VirtualFile> ticket_files;
-
-    VirtualFile romfs;
-    VirtualDir exefs;
-};
-} // namespace FileSys

src/core/file_sys/vfs.cpp

@@ -462,11 +462,4 @@ bool VfsRawCopy(VirtualFile src, VirtualFile dest) {
     std::vector<u8> data = src->ReadAllBytes();
     return dest->WriteBytes(data, 0) == data.size();
 }
-
-VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path) {
-    const auto res = rel->GetDirectoryRelative(path);
-    if (res == nullptr)
-        return rel->CreateDirectoryRelative(path);
-    return res;
-}
 } // namespace FileSys

src/core/file_sys/vfs.h

@@ -318,8 +318,4 @@ bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, size_t block
 // directory of src/dest.
 bool VfsRawCopy(VirtualFile src, VirtualFile dest);
 
-// Checks if the directory at path relative to rel exists. If it does, returns that. If it does not
-// it attempts to create it and returns the new dir or nullptr on failure.
-VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path);
-
 } // namespace FileSys

src/core/file_sys/vfs_real.cpp

@@ -8,7 +8,6 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/common_paths.h"
-#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/vfs_real.h"
 
@@ -40,7 +39,6 @@ static std::string ModeFlagsToString(Mode mode) {
 }
 
 RealVfsFilesystem::RealVfsFilesystem() : VfsFilesystem(nullptr) {}
-RealVfsFilesystem::~RealVfsFilesystem() = default;
 
 std::string RealVfsFilesystem::GetName() const {
     return "Real";
@@ -221,8 +219,6 @@ RealVfsFile::RealVfsFile(RealVfsFilesystem& base_, std::shared_ptr<FileUtil::IOF
       parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
       perms(perms_) {}
 
-RealVfsFile::~RealVfsFile() = default;
-
 std::string RealVfsFile::GetName() const {
     return path_components.back();
 }
@@ -316,8 +312,6 @@ RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string&
         FileUtil::CreateDir(path);
 }
 
-RealVfsDirectory::~RealVfsDirectory() = default;
-
 std::shared_ptr<VfsFile> RealVfsDirectory::GetFileRelative(std::string_view path) const {
     const auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(path));
     if (!FileUtil::Exists(full_path) || FileUtil::IsDirectory(full_path))
@@ -347,6 +341,7 @@ std::shared_ptr<VfsFile> RealVfsDirectory::CreateFileRelative(std::string_view p
 
 std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateDirectoryRelative(std::string_view path) {
     const auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(path));
+    auto parent = std::string(FileUtil::GetParentPath(full_path));
     return base.CreateDirectory(full_path, perms);
 }
 

src/core/file_sys/vfs_real.h

@@ -6,19 +6,15 @@
 
 #include <string_view>
 #include <boost/container/flat_map.hpp>
+#include "common/file_util.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs.h"
 
-namespace FileUtil {
-class IOFile;
-}
-
 namespace FileSys {
 
 class RealVfsFilesystem : public VfsFilesystem {
 public:
     RealVfsFilesystem();
-    ~RealVfsFilesystem() override;
 
     std::string GetName() const override;
     bool IsReadable() const override;
@@ -44,9 +40,10 @@ class RealVfsFile : public VfsFile {
     friend class RealVfsDirectory;
     friend class RealVfsFilesystem;
 
-public:
-    ~RealVfsFile() override;
+    RealVfsFile(RealVfsFilesystem& base, std::shared_ptr<FileUtil::IOFile> backing,
+                const std::string& path, Mode perms = Mode::Read);
 
+public:
     std::string GetName() const override;
     size_t GetSize() const override;
     bool Resize(size_t new_size) override;
@@ -58,9 +55,6 @@ public:
     bool Rename(std::string_view name) override;
 
 private:
-    RealVfsFile(RealVfsFilesystem& base, std::shared_ptr<FileUtil::IOFile> backing,
-                const std::string& path, Mode perms = Mode::Read);
-
     bool Close();
 
     RealVfsFilesystem& base;
@@ -76,9 +70,9 @@ private:
 class RealVfsDirectory : public VfsDirectory {
     friend class RealVfsFilesystem;
 
-public:
-    ~RealVfsDirectory() override;
+    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read);
 
+public:
     std::shared_ptr<VfsFile> GetFileRelative(std::string_view path) const override;
     std::shared_ptr<VfsDirectory> GetDirectoryRelative(std::string_view path) const override;
     std::shared_ptr<VfsFile> GetFile(std::string_view name) const override;
@@ -103,8 +97,6 @@ protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
-    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read);
-
     template <typename T, typename R>
     std::vector<std::shared_ptr<R>> IterateEntries() const;
 

src/core/file_sys/xts_archive.cpp

@@ -1,170 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-#include <regex>
-#include <string>
-#include <mbedtls/md.h>
-#include <mbedtls/sha256.h>
-#include "common/assert.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/xts_encryption_layer.h"
-#include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/vfs_offset.h"
-#include "core/file_sys/xts_archive.h"
-#include "core/loader/loader.h"
-
-namespace FileSys {
-
-constexpr u64 NAX_HEADER_PADDING_SIZE = 0x4000;
-
-template <typename SourceData, typename SourceKey, typename Destination>
-static bool CalculateHMAC256(Destination* out, const SourceKey* key, size_t key_length,
-                             const SourceData* data, size_t data_length) {
-    mbedtls_md_context_t context;
-    mbedtls_md_init(&context);
-
-    const auto key_f = reinterpret_cast<const u8*>(key);
-    const std::vector<u8> key_v(key_f, key_f + key_length);
-
-    if (mbedtls_md_setup(&context, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1) ||
-        mbedtls_md_hmac_starts(&context, reinterpret_cast<const u8*>(key), key_length) ||
-        mbedtls_md_hmac_update(&context, reinterpret_cast<const u8*>(data), data_length) ||
-        mbedtls_md_hmac_finish(&context, reinterpret_cast<u8*>(out))) {
-        mbedtls_md_free(&context);
-        return false;
-    }
-
-    mbedtls_md_free(&context);
-    return true;
-}
-
-NAX::NAX(VirtualFile file_) : file(std::move(file_)), header(std::make_unique<NAXHeader>()) {
-    std::string path = FileUtil::SanitizePath(file->GetFullPath());
-    static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
-                                           std::regex_constants::ECMAScript |
-                                               std::regex_constants::icase);
-    std::smatch match;
-    if (!std::regex_search(path, match, nax_path_regex)) {
-        status = Loader::ResultStatus::ErrorBadNAXFilePath;
-        return;
-    }
-
-    std::string two_dir = match[1];
-    std::string nca_id = match[2];
-    std::transform(two_dir.begin(), two_dir.end(), two_dir.begin(), ::toupper);
-    std::transform(nca_id.begin(), nca_id.end(), nca_id.begin(), ::tolower);
-
-    status = Parse(fmt::format("/registered/{}/{}.nca", two_dir, nca_id));
-}
-
-NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
-    : file(std::move(file_)), header(std::make_unique<NAXHeader>()) {
-    Core::Crypto::SHA256Hash hash{};
-    mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
-    status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],
-                               Common::HexArrayToString(nca_id, false)));
-}
-
-Loader::ResultStatus NAX::Parse(std::string_view path) {
-    if (file->ReadObject(header.get()) != sizeof(NAXHeader))
-        return Loader::ResultStatus::ErrorBadNAXHeader;
-
-    if (header->magic != Common::MakeMagic('N', 'A', 'X', '0'))
-        return Loader::ResultStatus::ErrorBadNAXHeader;
-
-    if (file->GetSize() < NAX_HEADER_PADDING_SIZE + header->file_size)
-        return Loader::ResultStatus::ErrorIncorrectNAXFileSize;
-
-    keys.DeriveSDSeedLazy();
-    std::array<Core::Crypto::Key256, 2> sd_keys{};
-    const auto sd_keys_res = Core::Crypto::DeriveSDKeys(sd_keys, keys);
-    if (sd_keys_res != Loader::ResultStatus::Success) {
-        return sd_keys_res;
-    }
-
-    const auto enc_keys = header->key_area;
-
-    size_t i = 0;
-    for (; i < sd_keys.size(); ++i) {
-        std::array<Core::Crypto::Key128, 2> nax_keys{};
-        if (!CalculateHMAC256(nax_keys.data(), sd_keys[i].data(), 0x10, std::string(path).c_str(),
-                              path.size())) {
-            return Loader::ResultStatus::ErrorNAXKeyHMACFailed;
-        }
-
-        for (size_t j = 0; j < nax_keys.size(); ++j) {
-            Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(nax_keys[j],
-                                                                 Core::Crypto::Mode::ECB);
-            cipher.Transcode(enc_keys[j].data(), 0x10, header->key_area[j].data(),
-                             Core::Crypto::Op::Decrypt);
-        }
-
-        Core::Crypto::SHA256Hash validation{};
-        if (!CalculateHMAC256(validation.data(), &header->magic, 0x60, sd_keys[i].data() + 0x10,
-                              0x10)) {
-            return Loader::ResultStatus::ErrorNAXValidationHMACFailed;
-        }
-        if (header->hmac == validation)
-            break;
-    }
-
-    if (i == 2) {
-        return Loader::ResultStatus::ErrorNAXKeyDerivationFailed;
-    }
-
-    type = static_cast<NAXContentType>(i);
-
-    Core::Crypto::Key256 final_key{};
-    std::memcpy(final_key.data(), &header->key_area, final_key.size());
-    const auto enc_file =
-        std::make_shared<OffsetVfsFile>(file, header->file_size, NAX_HEADER_PADDING_SIZE);
-    dec_file = std::make_shared<Core::Crypto::XTSEncryptionLayer>(enc_file, final_key);
-
-    return Loader::ResultStatus::Success;
-}
-
-Loader::ResultStatus NAX::GetStatus() const {
-    return status;
-}
-
-VirtualFile NAX::GetDecrypted() const {
-    return dec_file;
-}
-
-std::shared_ptr<NCA> NAX::AsNCA() const {
-    if (type == NAXContentType::NCA)
-        return std::make_shared<NCA>(GetDecrypted());
-    return nullptr;
-}
-
-NAXContentType NAX::GetContentType() const {
-    return type;
-}
-
-std::vector<std::shared_ptr<VfsFile>> NAX::GetFiles() const {
-    return {dec_file};
-}
-
-std::vector<std::shared_ptr<VfsDirectory>> NAX::GetSubdirectories() const {
-    return {};
-}
-
-std::string NAX::GetName() const {
-    return file->GetName();
-}
-
-std::shared_ptr<VfsDirectory> NAX::GetParentDirectory() const {
-    return file->GetContainingDirectory();
-}
-
-bool NAX::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    return false;
-}
-} // namespace FileSys

src/core/file_sys/xts_archive.h

@@ -1,69 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/crypto/key_manager.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/vfs.h"
-#include "core/loader/loader.h"
-
-namespace FileSys {
-
-struct NAXHeader {
-    std::array<u8, 0x20> hmac;
-    u64_le magic;
-    std::array<Core::Crypto::Key128, 2> key_area;
-    u64_le file_size;
-    INSERT_PADDING_BYTES(0x30);
-};
-static_assert(sizeof(NAXHeader) == 0x80, "NAXHeader has incorrect size.");
-
-enum class NAXContentType : u8 {
-    Save = 0,
-    NCA = 1,
-};
-
-class NAX : public ReadOnlyVfsDirectory {
-public:
-    explicit NAX(VirtualFile file);
-    explicit NAX(VirtualFile file, std::array<u8, 0x10> nca_id);
-
-    Loader::ResultStatus GetStatus() const;
-
-    VirtualFile GetDecrypted() const;
-
-    std::shared_ptr<NCA> AsNCA() const;
-
-    NAXContentType GetContentType() const;
-
-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
-
-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
-
-    std::string GetName() const override;
-
-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
-
-protected:
-    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
-
-private:
-    Loader::ResultStatus Parse(std::string_view path);
-
-    std::unique_ptr<NAXHeader> header;
-
-    VirtualFile file;
-    Loader::ResultStatus status;
-    NAXContentType type;
-
-    VirtualFile dec_file;
-
-    Core::Crypto::KeyManager keys;
-};
-} // namespace FileSys

src/core/hle/ipc_helpers.h

@@ -12,7 +12,6 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "core/core.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -136,9 +135,7 @@ public:
         if (context->Session()->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
-            auto& kernel = Core::System::GetInstance().Kernel();
-            auto sessions =
-                Kernel::ServerSession::CreateSessionPair(kernel, iface->GetServiceName());
+            auto sessions = Kernel::ServerSession::CreateSessionPair(iface->GetServiceName());
             auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
             auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
             iface->ClientConnected(server);

src/core/hle/kernel/address_arbiter.cpp

@@ -8,11 +8,9 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/result.h"
 #include "core/memory.h"

src/core/hle/kernel/client_port.cpp

@@ -14,7 +14,7 @@
 
 namespace Kernel {
 
-ClientPort::ClientPort(KernelCore& kernel) : Object{kernel} {}
+ClientPort::ClientPort() = default;
 ClientPort::~ClientPort() = default;
 
 ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
@@ -27,7 +27,7 @@ ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     active_sessions++;
 
     // Create a new session pair, let the created sessions inherit the parent port's HLE handler.
-    auto sessions = ServerSession::CreateSessionPair(kernel, server_port->GetName(), this);
+    auto sessions = ServerSession::CreateSessionPair(server_port->GetName(), this);
 
     if (server_port->hle_handler)
         server_port->hle_handler->ClientConnected(std::get<SharedPtr<ServerSession>>(sessions));

src/core/hle/kernel/client_port.h

@@ -11,9 +11,8 @@
 
 namespace Kernel {
 
-class ClientSession;
-class KernelCore;
 class ServerPort;
+class ClientSession;
 
 class ClientPort final : public Object {
 public:
@@ -45,7 +44,7 @@ public:
     void ConnectionClosed();
 
 private:
-    explicit ClientPort(KernelCore& kernel);
+    ClientPort();
     ~ClientPort() override;
 
     SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.

src/core/hle/kernel/client_session.cpp

@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-ClientSession::ClientSession(KernelCore& kernel) : Object{kernel} {}
+ClientSession::ClientSession() = default;
 ClientSession::~ClientSession() {
     // This destructor will be called automatically when the last ClientSession handle is closed by
     // the emulated application.

src/core/hle/kernel/client_session.h

@@ -12,9 +12,8 @@
 
 namespace Kernel {
 
-class KernelCore;
-class Session;
 class ServerSession;
+class Session;
 class Thread;
 
 class ClientSession final : public Object {
@@ -42,7 +41,7 @@ public:
     std::shared_ptr<Session> parent;
 
 private:
-    explicit ClientSession(KernelCore& kernel);
+    ClientSession();
     ~ClientSession() override;
 };
 

src/core/hle/kernel/errors.h

@@ -11,16 +11,17 @@ namespace Kernel {
 namespace ErrCodes {
 enum {
     // TODO(Subv): Remove these 3DS OS error codes.
+    OutOfHandles = 19,
     SessionClosedByRemote = 26,
+    PortNameTooLong = 30,
     NoPendingSessions = 35,
+    WrongPermission = 46,
     InvalidBufferDescriptor = 48,
+    MaxConnectionsReached = 52,
 
     // Confirmed Switch OS error codes
-    MaxConnectionsReached = 7,
     InvalidAddress = 102,
-    HandleTableFull = 105,
     InvalidMemoryState = 106,
-    InvalidMemoryPermissions = 108,
     InvalidProcessorId = 113,
     InvalidHandle = 114,
     InvalidCombination = 116,
@@ -29,7 +30,6 @@ enum {
     TooLarge = 119,
     InvalidEnumValue = 120,
     InvalidState = 125,
-    ResourceLimitExceeded = 132,
 };
 }
 
@@ -37,21 +37,18 @@ enum {
 // double check that the code matches before re-using the constant.
 
 // TODO(bunnei): Replace these with correct errors for Switch OS
-constexpr ResultCode ERR_HANDLE_TABLE_FULL(ErrorModule::Kernel, ErrCodes::HandleTableFull);
+constexpr ResultCode ERR_OUT_OF_HANDLES(-1);
 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_PORT_NAME_TOO_LONG(-1);
+constexpr ResultCode ERR_WRONG_PERMISSION(-1);
+constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED(-1);
 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_INVALID_COMBINATION_KERNEL(-1);
 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_HANDLE(ErrorModule::Kernel, ErrCodes::InvalidHandle);
 constexpr ResultCode ERR_INVALID_STATE(ErrorModule::Kernel, ErrCodes::InvalidState);
 constexpr ResultCode ERR_INVALID_POINTER(-1);

src/core/hle/kernel/event.cpp

@@ -10,11 +10,11 @@
 
 namespace Kernel {
 
-Event::Event(KernelCore& kernel) : WaitObject{kernel} {}
-Event::~Event() = default;
+Event::Event() {}
+Event::~Event() {}
 
-SharedPtr<Event> Event::Create(KernelCore& kernel, ResetType reset_type, std::string name) {
-    SharedPtr<Event> evt(new Event(kernel));
+SharedPtr<Event> Event::Create(ResetType reset_type, std::string name) {
+    SharedPtr<Event> evt(new Event);
 
     evt->signaled = false;
     evt->reset_type = reset_type;

src/core/hle/kernel/event.h

@@ -10,18 +10,14 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 class Event final : public WaitObject {
 public:
     /**
      * Creates an event
-     * @param kernel The kernel instance to create this event under.
      * @param reset_type ResetType describing how to create event
      * @param name Optional name of event
      */
-    static SharedPtr<Event> Create(KernelCore& kernel, ResetType reset_type,
-                                   std::string name = "Unknown");
+    static SharedPtr<Event> Create(ResetType reset_type, std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "Event";
@@ -48,7 +44,7 @@ public:
     void Clear();
 
 private:
-    explicit Event(KernelCore& kernel);
+    Event();
     ~Event() override;
 
     ResetType reset_type; ///< Current ResetType

src/core/hle/kernel/handle_table.cpp

@@ -13,6 +13,8 @@
 
 namespace Kernel {
 
+HandleTable g_handle_table;
+
 HandleTable::HandleTable() {
     next_generation = 1;
     Clear();
@@ -24,7 +26,7 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
     u16 slot = next_free_slot;
     if (slot >= generations.size()) {
         LOG_ERROR(Kernel, "Unable to allocate Handle, too many slots in use.");
-        return ERR_HANDLE_TABLE_FULL;
+        return ERR_OUT_OF_HANDLES;
     }
     next_free_slot = generations[slot];
 

src/core/hle/kernel/handle_table.h

@@ -47,7 +47,7 @@ public:
     /**
      * Allocates a handle for the given object.
      * @return The created Handle or one of the following errors:
-     *           - `ERR_HANDLE_TABLE_FULL`: the maximum number of handles has been exceeded.
+     *           - `ERR_OUT_OF_HANDLES`: the maximum number of handles has been exceeded.
      */
     ResultVal<Handle> Create(SharedPtr<Object> obj);
 
@@ -121,4 +121,6 @@ private:
     u16 next_free_slot;
 };
 
+extern HandleTable g_handle_table;
+
 } // namespace Kernel