Merge 51d4c772a2 into c0445006af

This gives us slightly increased memory safety, writing to out of bounds memory will be caught at the point of write instead of several calls down the line as memory corruption

.gitattributes

@@ -1,4 +0,0 @@
-dist/languages/* linguist-vendored
-dist/qt_themes/* linguist-vendored
-externals/* linguist-vendored
-*.h linguist-language=cpp

.gitmodules

@@ -13,6 +13,9 @@
 [submodule "dynarmic"]
     path = externals/dynarmic
     url = https://github.com/MerryMage/dynarmic.git
+[submodule "xbyak"]
+    path = externals/xbyak
+    url = https://github.com/herumi/xbyak.git
 [submodule "fmt"]
     path = externals/fmt
     url = https://github.com/fmtlib/fmt.git
@@ -31,9 +34,3 @@
 [submodule "soundtouch"]
 	path = externals/soundtouch
 	url = https://github.com/citra-emu/ext-soundtouch.git
-[submodule "libressl"]
-    path = externals/libressl
-    url = https://github.com/citra-emu/ext-libressl-portable.git
-[submodule "discord-rpc"]
-    path = externals/discord-rpc
-    url = https://github.com/discordapp/discord-rpc.git

.travis/clang-format/build.sh

@@ -1,3 +1,3 @@
 #!/bin/bash -ex
 
-docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache citraemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.travis/clang-format/docker.sh
+docker run -v $(pwd):/yuzu ubuntu:18.04 /bin/bash -ex /yuzu/.travis/clang-format/docker.sh

.travis/clang-format/deps.sh

@@ -1,3 +1,3 @@
 #!/bin/sh -ex
 
-docker pull citraemu/build-environments:linux-clang-format
+docker pull ubuntu:18.04

.travis/clang-format/docker.sh

@@ -1,5 +1,8 @@
 #!/bin/bash -ex
 
+apt-get update
+apt-get install -y clang-format-6.0
+
 # Run clang-format
 cd /yuzu
 ./.travis/clang-format/script.sh

.travis/clang-format/script.sh

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

.travis/common/travis-ci.env

@@ -10,7 +10,3 @@ TRAVIS_JOB_ID
 TRAVIS_JOB_NUMBER
 TRAVIS_REPO_SLUG
 TRAVIS_TAG
-
-# yuzu specific flags
-ENABLE_COMPATIBILITY_REPORTING
-USE_DISCORD_PRESENCE

.travis/linux-mingw/docker.sh

@@ -57,4 +57,3 @@ done
 
 pip3 install pefile
 python3 .travis/linux-mingw/scan_dll.py package/*.exe "package/"
-python3 .travis/linux-mingw/scan_dll.py package/imageformats/*.dll "package/"

.travis/linux/build.sh

@@ -1,4 +1,4 @@
 #!/bin/bash -ex
 
 mkdir -p "$HOME/.ccache"
-docker run -e ENABLE_COMPATIBILITY_REPORTING --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 --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

.travis/linux/docker.sh

@@ -6,7 +6,7 @@ apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev
 cd /yuzu
 
 mkdir build && cd build
-cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -G Ninja
+cmake .. -DYUZU_USE_BUNDLED_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
 ninja
 
 ccache -s

.travis/macos/build.sh

@@ -2,14 +2,14 @@
 
 set -o pipefail
 
-export MACOSX_DEPLOYMENT_TARGET=10.13
+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
 cmake --version
-cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON
 make -j4
 
 ccache -s

CMakeLists.txt

@@ -15,29 +15,25 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 option(ENABLE_QT "Enable the Qt frontend" ON)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
 
-option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
-
 option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
-option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
-
-if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/hooks/pre-commit)
+if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit)
     message(STATUS "Copying pre-commit hook")
     file(COPY hooks/pre-commit
-        DESTINATION ${PROJECT_SOURCE_DIR}/.git/hooks)
+        DESTINATION ${CMAKE_SOURCE_DIR}/.git/hooks)
 endif()
 
 # Sanity check : Check that all submodules are present
 # =======================================================================
 
 function(check_submodules_present)
-    file(READ "${PROJECT_SOURCE_DIR}/.gitmodules" gitmodules)
+    file(READ "${CMAKE_SOURCE_DIR}/.gitmodules" gitmodules)
     string(REGEX MATCHALL "path *= *[^ \t\r\n]*" gitmodules ${gitmodules})
     foreach(module ${gitmodules})
         string(REGEX REPLACE "path *= *" "" module ${module})
-        if (NOT EXISTS "${PROJECT_SOURCE_DIR}/${module}/.git")
+        if (NOT EXISTS "${CMAKE_SOURCE_DIR}/${module}/.git")
             message(FATAL_ERROR "Git submodule ${module} not found. "
                     "Please run: git submodule update --init --recursive")
         endif()
@@ -45,17 +41,17 @@ function(check_submodules_present)
 endfunction()
 check_submodules_present()
 
-configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
-               ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
+configure_file(${CMAKE_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
+               ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
                COPYONLY)
-if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
     message(STATUS "Downloading compatibility list for yuzu...")
     file(DOWNLOAD
         https://api.yuzu-emu.org/gamedb/
-        "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
+        "${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
 endif()
-if (NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    file(WRITE ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
+if (NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
+    file(WRITE ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
 endif()
 
 # Detect current compilation architecture and create standard definitions
@@ -127,6 +123,8 @@ else()
     # Avoid windows.h from including some usually unused libs like winsocks.h, since this might cause some redefinition errors.
     add_definitions(/DWIN32_LEAN_AND_MEAN)
 
+    # set up output paths for executable binaries (.exe-files, and .dll-files on DLL-capable platforms)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
     set(CMAKE_CONFIGURATION_TYPES Debug Release CACHE STRING "" FORCE)
 
     # Tweak optimization settings
@@ -170,7 +168,7 @@ endif()
 # On modern Unixes, this is typically already the case. The lone exception is
 # glibc, which may default to 32 bits. glibc allows this to be configured
 # by setting _FILE_OFFSET_BITS.
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     add_definitions(-D_FILE_OFFSET_BITS=64)
 endif()
 
@@ -178,6 +176,10 @@ endif()
 set_property(DIRECTORY APPEND PROPERTY
     COMPILE_DEFINITIONS $<$<CONFIG:Debug>:_DEBUG> $<$<NOT:$<CONFIG:Debug>>:NDEBUG>)
 
+
+math(EXPR EMU_ARCH_BITS ${CMAKE_SIZEOF_VOID_P}*8)
+add_definitions(-DEMU_ARCH_BITS=${EMU_ARCH_BITS})
+
 # System imported libraries
 # ======================
 
@@ -185,13 +187,13 @@ find_package(Boost 1.63.0 QUIET)
 if (NOT Boost_FOUND)
     message(STATUS "Boost 1.63.0 or newer not found, falling back to externals")
 
-    set(BOOST_ROOT "${PROJECT_SOURCE_DIR}/externals/boost")
+    set(BOOST_ROOT "${CMAKE_SOURCE_DIR}/externals/boost")
     set(Boost_NO_SYSTEM_PATHS OFF)
     find_package(Boost QUIET REQUIRED)
 endif()
 
 # Output binaries to bin/
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
@@ -260,7 +262,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
         endif()
 
         set(UNICORN_FOUND YES)
-        set(UNICORN_PREFIX ${PROJECT_SOURCE_DIR}/externals/unicorn)
+        set(UNICORN_PREFIX ${CMAKE_SOURCE_DIR}/externals/unicorn)
         set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/${UNICORN_LIB_NAME}" CACHE PATH "Path to Unicorn library" FORCE)
         set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
         set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/" CACHE PATH "Path to unicorn dynamic library" FORCE)
@@ -344,6 +346,14 @@ ELSEIF (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU|SunOS)$")
     set(PLATFORM_LIBRARIES rt)
 ENDIF (APPLE)
 
+# MINGW: GCC does not support codecvt, so use iconv instead
+if (UNIX OR MINGW)
+    find_library(ICONV_LIBRARY NAMES iconv)
+    if (ICONV_LIBRARY)
+        list(APPEND PLATFORM_LIBRARIES ${ICONV_LIBRARY})
+    endif()
+endif()
+
 # Setup a custom clang-format target (if clang-format can be found) that will run
 # against all the src files. This should be used before making a pull request.
 # =======================================================================
@@ -352,12 +362,12 @@ set(CLANG_FORMAT_POSTFIX "-6.0")
 find_program(CLANG_FORMAT
     NAMES clang-format${CLANG_FORMAT_POSTFIX}
           clang-format
-    PATHS ${PROJECT_BINARY_DIR}/externals)
+    PATHS ${CMAKE_BINARY_DIR}/externals)
 # if find_program doesn't find it, try to download from externals
 if (NOT CLANG_FORMAT)
     if (WIN32)
         message(STATUS "Clang format not found! Downloading...")
-        set(CLANG_FORMAT "${PROJECT_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
+        set(CLANG_FORMAT "${CMAKE_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
         file(DOWNLOAD
             https://github.com/yuzu-emu/ext-windows-bin/raw/master/clang-format${CLANG_FORMAT_POSTFIX}.exe
             "${CLANG_FORMAT}" SHOW_PROGRESS
@@ -373,11 +383,11 @@ if (NOT CLANG_FORMAT)
 endif()
 
 if (CLANG_FORMAT)
-    set(SRCS ${PROJECT_SOURCE_DIR}/src)
+    set(SRCS ${CMAKE_SOURCE_DIR}/src)
     set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
     if (WIN32)
         add_custom_target(clang-format
-            COMMAND powershell.exe -Command "Get-ChildItem ${SRCS}/* -Include *.cpp,*.h -Recurse | Foreach {${CLANG_FORMAT} -i $_.fullname}"
+            COMMAND powershell.exe -Command "${CLANG_FORMAT} -i @(Get-ChildItem -Recurse ${SRCS}/* -Include \'*.h\', \'*.cpp\')"
             COMMENT ${CCOMMENT})
     elseif(MINGW)
         add_custom_target(clang-format
@@ -446,10 +456,10 @@ endif()
 # http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
 # http://standards.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html
 if(ENABLE_QT AND UNIX AND NOT APPLE)
-    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.desktop"
+    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.desktop"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/applications")
-    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.svg"
+    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.svg"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/scalable/apps")
-    install(FILES "${PROJECT_SOURCE_DIR}/dist/yuzu.xml"
+    install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.xml"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/mime/packages")
 endif()

CONTRIBUTING.md

@@ -22,7 +22,7 @@ If clang format is found, then cmake will add a custom build target that can be
 * Don't ever introduce new external dependencies into Core
 * Don't use any platform specific code in Core
 * Use namespaces often
-* Avoid the use of C-style casts and instead prefer C++-style `static_cast` and `reinterpret_cast`. Try to avoid using `dynamic_cast`. Never use `const_cast`.
+* Avoid the use of C-style casts and instead prefer C++-style `static_cast` and `reinterpret_cast`. Try to avoid using `dynamic_cast`. Never use `const_cast`. The only exception to this rule is for casting between two numeric types, where C-style casts are encouraged for brevity and readability.
 
 ### Naming Rules
 * Functions: `PascalCase`

appveyor.yml

@@ -39,12 +39,11 @@ before_build:
   - mkdir %BUILD_TYPE%_build
   - cd %BUILD_TYPE%_build
   - ps: |
-        $COMPAT = if ($env:ENABLE_COMPATIBILITY_REPORTING -eq $null) {0} else {$env:ENABLE_COMPATIBILITY_REPORTING}
         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 -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=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 -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON .. 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 -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON .. 2>&1"
+          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"
         }
   - cd ..
 
@@ -125,6 +124,17 @@ after_build:
           Copy-Item -path "$CMAKE_SOURCE_DIR/license.txt" -destination $RELEASE_DIST
           Copy-Item -path "$CMAKE_SOURCE_DIR/README.md" -destination $RELEASE_DIST
 
+          # copy all the dll dependencies to the release folder
+          . "./.appveyor/UtilityFunctions.ps1"
+          $DLLSearchPath = "C:\msys64\mingw64\bin;$env:PATH"
+          $MingwDLLs = RecursivelyGetDeps $DLLSearchPath "$RELEASE_DIST\yuzu.exe"
+          $MingwDLLs += RecursivelyGetDeps $DLLSearchPath  "$RELEASE_DIST\yuzu_cmd.exe"
+          Write-Host "Detected the following dependencies:"
+          Write-Host $MingwDLLs
+          foreach ($file in $MingwDLLs) {
+            Copy-Item -path "$file" -force -destination "$RELEASE_DIST"
+          }
+
           # copy the qt windows plugin dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/platforms/qwindows.dll" -force -destination "$RELEASE_DIST/platforms"
 
@@ -134,18 +144,6 @@ after_build:
           # copy the qt jpeg imageformat dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/imageformats/qjpeg.dll" -force -destination "$RELEASE_DIST/imageformats"
 
-          # copy all the dll dependencies to the release folder
-          . "./.appveyor/UtilityFunctions.ps1"
-          $DLLSearchPath = "C:\msys64\mingw64\bin;$env:PATH"
-          $MingwDLLs = RecursivelyGetDeps $DLLSearchPath "$RELEASE_DIST\yuzu.exe"
-          $MingwDLLs += RecursivelyGetDeps $DLLSearchPath  "$RELEASE_DIST\yuzu_cmd.exe"
-          $MingwDLLs += RecursivelyGetDeps $DLLSearchPath  "$RELEASE_DIST\imageformats\qjpeg.dll"
-          Write-Host "Detected the following dependencies:"
-          Write-Host $MingwDLLs
-          foreach ($file in $MingwDLLs) {
-            Copy-Item -path "$file" -force -destination "$RELEASE_DIST"
-          }
-
           7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
           7z a $MINGW_SEVENZIP $RELEASE_DIST
         }

externals/CMakeLists.txt

@@ -9,6 +9,7 @@ target_include_directories(catch-single-include INTERFACE catch/single_include)
 
 # Dynarmic
 if (ARCHITECTURE_x86_64)
+    add_library(xbyak INTERFACE)
     set(DYNARMIC_TESTS OFF)
     set(DYNARMIC_NO_BUNDLED_FMT ON)
     add_subdirectory(dynarmic)
@@ -52,6 +53,14 @@ target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 # SoundTouch
 add_subdirectory(soundtouch)
 
+# Xbyak
+if (ARCHITECTURE_x86_64)
+    # Defined before "dynarmic" above
+    # add_library(xbyak INTERFACE)
+    target_include_directories(xbyak INTERFACE ./xbyak/xbyak)
+    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
+endif()
+
 # Opus
 add_subdirectory(opus)
 target_include_directories(opus INTERFACE ./opus/include)
@@ -61,28 +70,3 @@ if(ENABLE_CUBEB)
     set(BUILD_TESTS OFF CACHE BOOL "")
     add_subdirectory(cubeb EXCLUDE_FROM_ALL)
 endif()
-
-# DiscordRPC
-if (USE_DISCORD_PRESENCE)
-    add_subdirectory(discord-rpc EXCLUDE_FROM_ALL)
-    target_include_directories(discord-rpc INTERFACE ./discord-rpc/include)
-endif()
-
-if (ENABLE_WEB_SERVICE)
-    # LibreSSL
-    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
-    add_subdirectory(libressl EXCLUDE_FROM_ALL)
-    target_include_directories(ssl INTERFACE ./libressl/include)
-	target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
-
-    # lurlparser
-    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
-
-    # httplib
-    add_library(httplib INTERFACE)
-    target_include_directories(httplib INTERFACE ./httplib)
-
-    # JSON
-    add_library(json-headers INTERFACE)
-    target_include_directories(json-headers INTERFACE ./json)
-endif()

externals/cmake-modules/GetGitRevisionDescription.cmake.in

@@ -33,10 +33,6 @@ else()
 endif()
 
 if(NOT HEAD_HASH)
-	if(EXISTS "@GIT_DATA@/head-ref")
-		file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-		string(STRIP "${HEAD_HASH}" HEAD_HASH)
-	else()
-		set(HEAD_HASH "Unknown")
-	endif()
+	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+	string(STRIP "${HEAD_HASH}" HEAD_HASH)
 endif()

externals/httplib/README.md

@@ -1,15 +0,0 @@
-From https://github.com/yhirose/cpp-httplib/commit/d9479bc0b12e8a1e8bce2d34da4feeef488581f3
-
-MIT License
-
-===
-
-cpp-httplib
-
-A C++11 header-only HTTP library.
-
-It's extremely easy to setup. Just include httplib.h file in your code!
-
-Inspired by Sinatra and express.
-
-© 2017 Yuji Hirose

externals/json/README.md

@@ -1,9 +0,0 @@
-JSON for Modern C++
-===================
-
-v3.1.2
-
-This is a mirror providing the single required header file.
-
-The original repository can be found at:
-https://github.com/nlohmann/json/commit/d2dd27dc3b8472dbaa7d66f83619b3ebcd9185fe

externals/lurlparser/CMakeLists.txt

@@ -1,8 +0,0 @@
-add_library(lurlparser
-        LUrlParser.cpp
-        LUrlParser.h
-)
-
-create_target_directory_groups(lurlparser)
-
-target_include_directories(lurlparser INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

externals/lurlparser/LUrlParser.cpp

@@ -1,265 +0,0 @@
-/*
- * Lightweight URL & URI parser (RFC 1738, RFC 3986)
- * https://github.com/corporateshark/LUrlParser
- *
- * The MIT License (MIT)
- *
- * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "LUrlParser.h"
-
-#include <algorithm>
-#include <cstring>
-#include <stdlib.h>
-
-// check if the scheme name is valid
-static bool IsSchemeValid( const std::string& SchemeName )
-{
-    for ( auto c : SchemeName  )
-    {
-        if ( !isalpha( c ) && c != '+' && c != '-' && c != '.' ) return false;
-    }
-
-    return true;
-}
-
-bool LUrlParser::clParseURL::GetPort( int* OutPort ) const
-{
-    if ( !IsValid() ) { return false; }
-
-    int Port = atoi( m_Port.c_str() );
-
-    if ( Port <= 0 || Port > 65535 ) { return false; }
-
-    if ( OutPort ) { *OutPort = Port; }
-
-    return true;
-}
-
-// based on RFC 1738 and RFC 3986
-LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL( const std::string& URL )
-{
-    LUrlParser::clParseURL Result;
-
-    const char* CurrentString = URL.c_str();
-
-    /*
-     *	<scheme>:<scheme-specific-part>
-     *	<scheme> := [a-z\+\-\.]+
-     *	For resiliency, programs interpreting URLs should treat upper case letters as equivalent to lower case in scheme names
-     */
-
-    // try to read scheme
-    {
-        const char* LocalString = strchr( CurrentString, ':' );
-
-        if ( !LocalString )
-        {
-            return clParseURL( LUrlParserError_NoUrlCharacter );
-        }
-
-        // save the scheme name
-        Result.m_Scheme = std::string( CurrentString, LocalString - CurrentString );
-
-        if ( !IsSchemeValid( Result.m_Scheme ) )
-        {
-            return clParseURL( LUrlParserError_InvalidSchemeName );
-        }
-
-        // scheme should be lowercase
-        std::transform( Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower );
-
-        // skip ':'
-        CurrentString = LocalString+1;
-    }
-
-    /*
-     *	//<user>:<password>@<host>:<port>/<url-path>
-     *	any ":", "@" and "/" must be normalized
-     */
-
-    // skip "//"
-    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
-    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
-
-    // check if the user name and password are specified
-    bool bHasUserName = false;
-
-    const char* LocalString = CurrentString;
-
-    while ( *LocalString )
-    {
-        if ( *LocalString == '@' )
-        {
-            // user name and password are specified
-            bHasUserName = true;
-            break;
-        }
-        else if ( *LocalString == '/' )
-        {
-            // end of <host>:<port> specification
-            bHasUserName = false;
-            break;
-        }
-
-        LocalString++;
-    }
-
-    // user name and password
-    LocalString = CurrentString;
-
-    if ( bHasUserName )
-    {
-        // read user name
-        while ( *LocalString && *LocalString != ':' && *LocalString != '@' ) LocalString++;
-
-        Result.m_UserName = std::string( CurrentString, LocalString - CurrentString );
-
-        // proceed with the current pointer
-        CurrentString = LocalString;
-
-        if ( *CurrentString == ':' )
-        {
-            // skip ':'
-            CurrentString++;
-
-            // read password
-            LocalString = CurrentString;
-
-            while ( *LocalString && *LocalString != '@' ) LocalString++;
-
-            Result.m_Password = std::string( CurrentString, LocalString - CurrentString );
-
-            CurrentString = LocalString;
-        }
-
-        // skip '@'
-        if ( *CurrentString != '@' )
-        {
-            return clParseURL( LUrlParserError_NoAtSign );
-        }
-
-        CurrentString++;
-    }
-
-    bool bHasBracket = ( *CurrentString == '[' );
-
-    // go ahead, read the host name
-    LocalString = CurrentString;
-
-    while ( *LocalString )
-    {
-        if ( bHasBracket && *LocalString == ']' )
-        {
-            // end of IPv6 address
-            LocalString++;
-            break;
-        }
-        else if ( !bHasBracket && ( *LocalString == ':' || *LocalString == '/' ) )
-        {
-            // port number is specified
-            break;
-        }
-
-        LocalString++;
-    }
-
-    Result.m_Host = std::string( CurrentString, LocalString - CurrentString );
-
-    CurrentString = LocalString;
-
-    // is port number specified?
-    if ( *CurrentString == ':' )
-    {
-        CurrentString++;
-
-        // read port number
-        LocalString = CurrentString;
-
-        while ( *LocalString && *LocalString != '/' ) LocalString++;
-
-        Result.m_Port = std::string( CurrentString, LocalString - CurrentString );
-
-        CurrentString = LocalString;
-    }
-
-    // end of string
-    if ( !*CurrentString )
-    {
-        Result.m_ErrorCode = LUrlParserError_Ok;
-
-        return Result;
-    }
-
-    // skip '/'
-    if ( *CurrentString != '/' )
-    {
-        return clParseURL( LUrlParserError_NoSlash );
-    }
-
-    CurrentString++;
-
-    // parse the path
-    LocalString = CurrentString;
-
-    while ( *LocalString && *LocalString != '#' && *LocalString != '?' ) LocalString++;
-
-    Result.m_Path = std::string( CurrentString, LocalString - CurrentString );
-
-    CurrentString = LocalString;
-
-    // check for query
-    if ( *CurrentString == '?' )
-    {
-        // skip '?'
-        CurrentString++;
-
-        // read query
-        LocalString = CurrentString;
-
-        while ( *LocalString && *LocalString != '#' ) LocalString++;
-
-        Result.m_Query = std::string( CurrentString, LocalString - CurrentString );
-
-        CurrentString = LocalString;
-    }
-
-    // check for fragment
-    if ( *CurrentString == '#' )
-    {
-        // skip '#'
-        CurrentString++;
-
-        // read fragment
-        LocalString = CurrentString;
-
-        while ( *LocalString ) LocalString++;
-
-        Result.m_Fragment = std::string( CurrentString, LocalString - CurrentString );
-
-        CurrentString = LocalString;
-    }
-
-    Result.m_ErrorCode = LUrlParserError_Ok;
-
-    return Result;
-}

externals/lurlparser/LUrlParser.h

@@ -1,78 +0,0 @@
-/*
- * Lightweight URL & URI parser (RFC 1738, RFC 3986)
- * https://github.com/corporateshark/LUrlParser
- *
- * The MIT License (MIT)
- *
- * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#pragma once
-
-#include <string>
-
-namespace LUrlParser
-{
-enum LUrlParserError
-{
-    LUrlParserError_Ok = 0,
-    LUrlParserError_Uninitialized = 1,
-    LUrlParserError_NoUrlCharacter = 2,
-    LUrlParserError_InvalidSchemeName = 3,
-    LUrlParserError_NoDoubleSlash = 4,
-    LUrlParserError_NoAtSign = 5,
-    LUrlParserError_UnexpectedEndOfLine = 6,
-    LUrlParserError_NoSlash = 7,
-};
-
-class clParseURL
-{
-public:
-    LUrlParserError m_ErrorCode;
-    std::string m_Scheme;
-    std::string m_Host;
-    std::string m_Port;
-    std::string m_Path;
-    std::string m_Query;
-    std::string m_Fragment;
-    std::string m_UserName;
-    std::string m_Password;
-
-    clParseURL()
-            : m_ErrorCode( LUrlParserError_Uninitialized )
-    {}
-
-    /// return 'true' if the parsing was successful
-    bool IsValid() const { return m_ErrorCode == LUrlParserError_Ok; }
-
-    /// helper to convert the port number to int, return 'true' if the port is valid (within the 0..65535 range)
-    bool GetPort( int* OutPort ) const;
-
-    /// parse the URL
-    static clParseURL ParseURL( const std::string& URL );
-
-private:
-    explicit clParseURL( LUrlParserError ErrorCode )
-            : m_ErrorCode( ErrorCode )
-    {}
-};
-
-} // namespace LUrlParser

externals/lurlparser/README.md

@@ -1,19 +0,0 @@
-From https://github.com/corporateshark/LUrlParser/commit/455d5e2d27e3946f11ad0328fee9ee2628e6a8e2
-
-MIT License
-
-===
-
-Lightweight URL & URI parser (RFC 1738, RFC 3986)
-
-(C) Sergey Kosarevsky, 2015
-
-@corporateshark sk@linderdaum.com
-
-http://www.linderdaum.com
-
-http://blog.linderdaum.com
-
-=============================
-
-A tiny and lightweight URL & URI parser (RFC 1738, RFC 3986) written in C++.

src/CMakeLists.txt

@@ -13,6 +13,3 @@ endif()
 if (ENABLE_QT)
     add_subdirectory(yuzu)
 endif()
-if (ENABLE_WEB_SERVICE)
-    add_subdirectory(web_service)
-endif()

src/audio_core/audio_renderer.cpp

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

src/audio_core/audio_renderer.h

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

src/audio_core/cubeb_sink.cpp

@@ -121,8 +121,7 @@ CubebSink::CubebSink(std::string target_device_name) {
             const auto collection_end{collection.device + collection.count};
             const auto device{
                 std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
-                    return info.friendly_name != nullptr &&
-                           target_device_name == info.friendly_name;
+                    return target_device_name == info.friendly_name;
                 })};
             if (device != collection_end) {
                 output_device = device->devid;

src/audio_core/stream.cpp

@@ -11,6 +11,7 @@
 #include "audio_core/stream.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "common/microprofile.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/settings.h"
@@ -52,8 +53,8 @@ void Stream::Stop() {
     ASSERT_MSG(false, "Unimplemented");
 }
 
-Stream::State Stream::GetState() const {
-    return state;
+u32 Stream::GetState() const {
+    return static_cast<u32>(state);
 }
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
@@ -103,7 +104,10 @@ void Stream::PlayNextBuffer() {
     CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
+MICROPROFILE_DEFINE(AudioOutput, "Audio", "ReleaseActiveBuffer", MP_RGB(100, 100, 255));
+
 void Stream::ReleaseActiveBuffer() {
+    MICROPROFILE_SCOPE(AudioOutput);
     ASSERT(active_buffer);
     released_buffers.push(std::move(active_buffer));
     release_callback();

src/audio_core/stream.h

@@ -33,12 +33,6 @@ public:
         Multi51Channel16,
     };
 
-    /// Current state of the stream
-    enum class State {
-        Stopped,
-        Playing,
-    };
-
     /// Callback function type, used to change guest state on a buffer being released
     using ReleaseCallback = std::function<void()>;
 
@@ -79,9 +73,15 @@ public:
     u32 GetNumChannels() const;
 
     /// Get the state
-    State GetState() const;
+    u32 GetState() const;
 
 private:
+    /// Current state of the stream
+    enum class State {
+        Stopped,
+        Playing,
+    };
+
     /// Plays the next queued buffer in the audio stream, starting playback if necessary
     void PlayNextBuffer();
 

src/audio_core/time_stretch.cpp

@@ -10,7 +10,8 @@
 
 namespace AudioCore {
 
-TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count) : m_sample_rate{sample_rate} {
+TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count)
+    : m_sample_rate(sample_rate), m_channel_count(channel_count) {
     m_sound_touch.setChannels(channel_count);
     m_sound_touch.setSampleRate(sample_rate);
     m_sound_touch.setPitch(1.0);
@@ -32,10 +33,10 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
     // We were given actual_samples number of samples, and num_samples were requested from us.
     double current_ratio = static_cast<double>(num_in) / static_cast<double>(num_out);
 
-    const double max_latency = 0.25; // seconds
+    const double max_latency = 1.0; // seconds
     const double max_backlog = m_sample_rate * max_latency;
     const double backlog_fullness = m_sound_touch.numSamples() / max_backlog;
-    if (backlog_fullness > 4.0) {
+    if (backlog_fullness > 5.0) {
         // Too many samples in backlog: Don't push anymore on
         num_in = 0;
     }
@@ -49,7 +50,7 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
 
     // This low-pass filter smoothes out variance in the calculated stretch ratio.
     // The time-scale determines how responsive this filter is.
-    constexpr double lpf_time_scale = 0.712; // seconds
+    constexpr double lpf_time_scale = 2.0; // seconds
     const double lpf_gain = 1.0 - std::exp(-time_delta / lpf_time_scale);
     m_stretch_ratio += lpf_gain * (current_ratio - m_stretch_ratio);
 

src/audio_core/time_stretch.h

@@ -27,6 +27,7 @@ public:
 
 private:
     u32 m_sample_rate;
+    u32 m_channel_count;
     soundtouch::SoundTouch m_sound_touch;
     double m_stretch_ratio = 1.0;
 };

src/common/CMakeLists.txt

@@ -29,7 +29,7 @@ if ($ENV{CI})
       if (BUILD_VERSION)
         # This leaves a trailing space on the last word, but we actually want that
         # because of how it's styled in the title bar.
-        set(BUILD_FULLNAME "${REPO_NAME} ${BUILD_VERSION} ")
+        set(BUILD_FULLNAME "${REPO_NAME} #${BUILD_VERSION} ")
       else()
         set(BUILD_FULLNAME "")
       endif()
@@ -41,9 +41,8 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in" "${CMAKE_CURRENT_SOU
 add_library(common STATIC
     alignment.h
     assert.h
-    detached_tasks.cpp
-    detached_tasks.h
     bit_field.h
+    bit_set.h
     cityhash.cpp
     cityhash.h
     color.h
@@ -63,6 +62,8 @@ add_library(common STATIC
     logging/text_formatter.cpp
     logging/text_formatter.h
     math_util.h
+    memory_util.cpp
+    memory_util.h
     microprofile.cpp
     microprofile.h
     microprofileui.h
@@ -86,7 +87,6 @@ add_library(common STATIC
     timer.cpp
     timer.h
     vector_math.h
-    web_result.h
 )
 
 if(ARCHITECTURE_x86_64)
@@ -94,9 +94,14 @@ if(ARCHITECTURE_x86_64)
         PRIVATE
             x64/cpu_detect.cpp
             x64/cpu_detect.h
+            x64/xbyak_abi.h
+            x64/xbyak_util.h
     )
 endif()
 
 create_target_directory_groups(common)
 
 target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
+if (ARCHITECTURE_x86_64)
+    target_link_libraries(common PRIVATE xbyak)
+endif()

src/common/alignment.h

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

src/common/assert.h

@@ -52,8 +52,5 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
 
-#define UNIMPLEMENTED() ASSERT_MSG(false, "Unimplemented code!")
+#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
-
-#define UNIMPLEMENTED_IF(cond) ASSERT_MSG(!(cond), "Unimplemented code!")
-#define UNIMPLEMENTED_IF_MSG(cond, ...) ASSERT_MSG(!(cond), __VA_ARGS__)

src/common/bit_field.h

@@ -117,21 +117,21 @@ private:
     // We don't delete it because we want BitField to be trivially copyable.
     constexpr BitField& operator=(const BitField&) = default;
 
-    // UnderlyingType is T for non-enum types and the underlying type of T if
+    // StorageType is T for non-enum types and the underlying type of T if
     // T is an enumeration. Note that T is wrapped within an enable_if in the
     // former case to workaround compile errors which arise when using
     // std::underlying_type<T>::type directly.
-    using UnderlyingType = typename std::conditional_t<std::is_enum_v<T>, std::underlying_type<T>,
-                                                       std::enable_if<true, T>>::type;
+    using StorageType = typename std::conditional_t<std::is_enum<T>::value, std::underlying_type<T>,
+                                                    std::enable_if<true, T>>::type;
 
-    // We store the value as the unsigned type to avoid undefined behaviour on value shifting
-    using StorageType = std::make_unsigned_t<UnderlyingType>;
+    // Unsigned version of StorageType
+    using StorageTypeU = std::make_unsigned_t<StorageType>;
 
 public:
     /// Constants to allow limited introspection of fields if needed
     static constexpr std::size_t position = Position;
     static constexpr std::size_t bits = Bits;
-    static constexpr StorageType mask = (((StorageType)~0) >> (8 * sizeof(T) - bits)) << position;
+    static constexpr StorageType mask = (((StorageTypeU)~0) >> (8 * sizeof(T) - bits)) << position;
 
     /**
      * Formats a value by masking and shifting it according to the field parameters. A value
@@ -148,12 +148,11 @@ public:
      * union in a constexpr context.
      */
     static constexpr FORCE_INLINE T ExtractValue(const StorageType& storage) {
-        if constexpr (std::numeric_limits<UnderlyingType>::is_signed) {
+        if (std::numeric_limits<T>::is_signed) {
             std::size_t shift = 8 * sizeof(T) - bits;
-            return static_cast<T>(static_cast<UnderlyingType>(storage << (shift - position)) >>
-                                  shift);
+            return (T)((storage << (shift - position)) >> shift);
         } else {
-            return static_cast<T>((storage & mask) >> position);
+            return (T)((storage & mask) >> position);
         }
     }
 

src/common/bit_set.h

@@ -0,0 +1,244 @@
+// This file is under the public domain.
+
+#pragma once
+
+#include <cstddef>
+#ifdef _WIN32
+#include <intrin.h>
+#endif
+#include <initializer_list>
+#include <new>
+#include <type_traits>
+#include "common/common_types.h"
+
+// namespace avoids conflict with OS X Carbon; don't use BitSet<T> directly
+namespace Common {
+
+// Helper functions:
+
+#ifdef _MSC_VER
+template <typename T>
+static inline int CountSetBits(T v) {
+    // from https://graphics.stanford.edu/~seander/bithacks.html
+    // GCC has this built in, but MSVC's intrinsic will only emit the actual
+    // POPCNT instruction, which we're not depending on
+    v = v - ((v >> 1) & (T) ~(T)0 / 3);
+    v = (v & (T) ~(T)0 / 15 * 3) + ((v >> 2) & (T) ~(T)0 / 15 * 3);
+    v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15;
+    return (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;
+}
+static inline int LeastSignificantSetBit(u8 val) {
+    unsigned long index;
+    _BitScanForward(&index, val);
+    return (int)index;
+}
+static inline int LeastSignificantSetBit(u16 val) {
+    unsigned long index;
+    _BitScanForward(&index, val);
+    return (int)index;
+}
+static inline int LeastSignificantSetBit(u32 val) {
+    unsigned long index;
+    _BitScanForward(&index, val);
+    return (int)index;
+}
+static inline int LeastSignificantSetBit(u64 val) {
+    unsigned long index;
+    _BitScanForward64(&index, val);
+    return (int)index;
+}
+#else
+static inline int CountSetBits(u8 val) {
+    return __builtin_popcount(val);
+}
+static inline int CountSetBits(u16 val) {
+    return __builtin_popcount(val);
+}
+static inline int CountSetBits(u32 val) {
+    return __builtin_popcount(val);
+}
+static inline int CountSetBits(u64 val) {
+    return __builtin_popcountll(val);
+}
+static inline int LeastSignificantSetBit(u8 val) {
+    return __builtin_ctz(val);
+}
+static inline int LeastSignificantSetBit(u16 val) {
+    return __builtin_ctz(val);
+}
+static inline int LeastSignificantSetBit(u32 val) {
+    return __builtin_ctz(val);
+}
+static inline int LeastSignificantSetBit(u64 val) {
+    return __builtin_ctzll(val);
+}
+#endif
+
+// Similar to std::bitset, this is a class which encapsulates a bitset, i.e.
+// using the set bits of an integer to represent a set of integers.  Like that
+// class, it acts like an array of bools:
+//     BitSet32 bs;
+//     bs[1] = true;
+// but also like the underlying integer ([0] = least significant bit):
+//     BitSet32 bs2 = ...;
+//     bs = (bs ^ bs2) & BitSet32(0xffff);
+// The following additional functionality is provided:
+// - Construction using an initializer list.
+//     BitSet bs { 1, 2, 4, 8 };
+// - Efficiently iterating through the set bits:
+//     for (int i : bs)
+//         [i is the *index* of a set bit]
+//   (This uses the appropriate CPU instruction to find the next set bit in one
+//   operation.)
+// - Counting set bits using .Count() - see comment on that method.
+
+// TODO: use constexpr when MSVC gets out of the Dark Ages
+
+template <typename IntTy>
+class BitSet {
+    static_assert(!std::is_signed_v<IntTy>, "BitSet should not be used with signed types");
+
+public:
+    // A reference to a particular bit, returned from operator[].
+    class Ref {
+    public:
+        Ref(Ref&& other) : m_bs(other.m_bs), m_mask(other.m_mask) {}
+        Ref(BitSet* bs, IntTy mask) : m_bs(bs), m_mask(mask) {}
+        operator bool() const {
+            return (m_bs->m_val & m_mask) != 0;
+        }
+        bool operator=(bool set) {
+            m_bs->m_val = (m_bs->m_val & ~m_mask) | (set ? m_mask : 0);
+            return set;
+        }
+
+    private:
+        BitSet* m_bs;
+        IntTy m_mask;
+    };
+
+    // A STL-like iterator is required to be able to use range-based for loops.
+    class Iterator {
+    public:
+        Iterator(const Iterator& other) : m_val(other.m_val), m_bit(other.m_bit) {}
+        Iterator(IntTy val) : m_val(val), m_bit(0) {}
+        Iterator& operator=(Iterator other) {
+            new (this) Iterator(other);
+            return *this;
+        }
+        int operator*() {
+            return m_bit + ComputeLsb();
+        }
+        Iterator& operator++() {
+            int lsb = ComputeLsb();
+            m_val >>= lsb + 1;
+            m_bit += lsb + 1;
+            m_has_lsb = false;
+            return *this;
+        }
+        Iterator operator++(int _) {
+            Iterator other(*this);
+            ++*this;
+            return other;
+        }
+        bool operator==(Iterator other) const {
+            return m_val == other.m_val;
+        }
+        bool operator!=(Iterator other) const {
+            return m_val != other.m_val;
+        }
+
+    private:
+        int ComputeLsb() {
+            if (!m_has_lsb) {
+                m_lsb = LeastSignificantSetBit(m_val);
+                m_has_lsb = true;
+            }
+            return m_lsb;
+        }
+        IntTy m_val;
+        int m_bit;
+        int m_lsb = -1;
+        bool m_has_lsb = false;
+    };
+
+    BitSet() : m_val(0) {}
+    explicit BitSet(IntTy val) : m_val(val) {}
+    BitSet(std::initializer_list<int> init) {
+        m_val = 0;
+        for (int bit : init)
+            m_val |= (IntTy)1 << bit;
+    }
+
+    static BitSet AllTrue(std::size_t count) {
+        return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1));
+    }
+
+    Ref operator[](std::size_t bit) {
+        return Ref(this, (IntTy)1 << bit);
+    }
+    const Ref operator[](std::size_t bit) const {
+        return (*const_cast<BitSet*>(this))[bit];
+    }
+    bool operator==(BitSet other) const {
+        return m_val == other.m_val;
+    }
+    bool operator!=(BitSet other) const {
+        return m_val != other.m_val;
+    }
+    bool operator<(BitSet other) const {
+        return m_val < other.m_val;
+    }
+    bool operator>(BitSet other) const {
+        return m_val > other.m_val;
+    }
+    BitSet operator|(BitSet other) const {
+        return BitSet(m_val | other.m_val);
+    }
+    BitSet operator&(BitSet other) const {
+        return BitSet(m_val & other.m_val);
+    }
+    BitSet operator^(BitSet other) const {
+        return BitSet(m_val ^ other.m_val);
+    }
+    BitSet operator~() const {
+        return BitSet(~m_val);
+    }
+    BitSet& operator|=(BitSet other) {
+        return *this = *this | other;
+    }
+    BitSet& operator&=(BitSet other) {
+        return *this = *this & other;
+    }
+    BitSet& operator^=(BitSet other) {
+        return *this = *this ^ other;
+    }
+    operator u32() = delete;
+    operator bool() {
+        return m_val != 0;
+    }
+
+    // Warning: Even though on modern CPUs this is a single fast instruction,
+    // Dolphin's official builds do not currently assume POPCNT support on x86,
+    // so slower explicit bit twiddling is generated.  Still should generally
+    // be faster than a loop.
+    unsigned int Count() const {
+        return CountSetBits(m_val);
+    }
+
+    Iterator begin() const {
+        return Iterator(m_val);
+    }
+    Iterator end() const {
+        return Iterator(0);
+    }
+
+    IntTy m_val;
+};
+
+} // namespace Common
+
+typedef Common::BitSet<u8> BitSet8;
+typedef Common::BitSet<u16> BitSet16;
+typedef Common::BitSet<u32> BitSet32;
+typedef Common::BitSet<u64> BitSet64;

src/common/detached_tasks.cpp

@@ -1,41 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <thread>
-#include "common/assert.h"
-#include "common/detached_tasks.h"
-
-namespace Common {
-
-DetachedTasks* DetachedTasks::instance = nullptr;
-
-DetachedTasks::DetachedTasks() {
-    ASSERT(instance == nullptr);
-    instance = this;
-}
-
-void DetachedTasks::WaitForAllTasks() {
-    std::unique_lock<std::mutex> lock(mutex);
-    cv.wait(lock, [this]() { return count == 0; });
-}
-
-DetachedTasks::~DetachedTasks() {
-    std::unique_lock<std::mutex> lock(mutex);
-    ASSERT(count == 0);
-    instance = nullptr;
-}
-
-void DetachedTasks::AddTask(std::function<void()> task) {
-    std::unique_lock<std::mutex> lock(instance->mutex);
-    ++instance->count;
-    std::thread([task{std::move(task)}]() {
-        task();
-        std::unique_lock<std::mutex> lock(instance->mutex);
-        --instance->count;
-        std::notify_all_at_thread_exit(instance->cv, std::move(lock));
-    })
-        .detach();
-}
-
-} // namespace Common

src/common/detached_tasks.h

@@ -1,40 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <condition_variable>
-#include <functional>
-
-namespace Common {
-
-/**
- * A background manager which ensures that all detached task is finished before program exits.
- *
- * Some tasks, telemetry submission for example, prefer executing asynchronously and don't care
- * about the result. These tasks are suitable for std::thread::detach(). However, this is unsafe if
- * the task is launched just before the program exits (which is a common case for telemetry), so we
- * need to block on these tasks on program exit.
- *
- * To make detached task safe, a single DetachedTasks object should be placed in the main(), and
- * call WaitForAllTasks() after all program execution but before global/static variable destruction.
- * Any potentially unsafe detached task should be executed via DetachedTasks::AddTask.
- */
-class DetachedTasks {
-public:
-    DetachedTasks();
-    ~DetachedTasks();
-    void WaitForAllTasks();
-
-    static void AddTask(std::function<void()> task);
-
-private:
-    static DetachedTasks* instance;
-
-    std::condition_variable cv;
-    std::mutex mutex;
-    int count = 0;
-};
-
-} // namespace Common

src/common/file_util.cpp

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

src/common/file_util.h

@@ -285,7 +285,7 @@ private:
 template <typename T>
 void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode) {
 #ifdef _MSC_VER
-    fstream.open(Common::UTF8ToUTF16W(filename).c_str(), openmode);
+    fstream.open(Common::UTF8ToTStr(filename).c_str(), openmode);
 #else
     fstream.open(filename.c_str(), openmode);
 #endif

src/common/hex_util.cpp

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

src/common/hex_util.h

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

src/common/logging/backend.cpp

@@ -12,8 +12,7 @@
 #include <thread>
 #include <vector>
 #ifdef _WIN32
-#include <share.h>   // For _SH_DENYWR
-#include <windows.h> // For OutputDebugStringA
+#include <share.h> // For _SH_DENYWR
 #else
 #define _SH_DENYWR 0
 #endif
@@ -140,18 +139,12 @@ void FileBackend::Write(const Entry& entry) {
     if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
         return;
     }
-    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
+    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
     if (entry.log_level >= Level::Error) {
         file.Flush();
     }
 }
 
-void DebuggerBackend::Write(const Entry& entry) {
-#ifdef _WIN32
-    ::OutputDebugStringA(FormatLogMessage(entry).append(1, '\n').c_str());
-#endif
-}
-
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
     CLS(Log)                                                                                       \
@@ -203,7 +196,6 @@ void DebuggerBackend::Write(const Entry& entry) {
     SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NIM)                                                                              \
-    SUB(Service, NPNS)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
     SUB(Service, PCIE)                                                                             \
@@ -212,12 +204,10 @@ void DebuggerBackend::Write(const Entry& entry) {
     SUB(Service, PM)                                                                               \
     SUB(Service, PREPO)                                                                            \
     SUB(Service, PSC)                                                                              \
-    SUB(Service, PSM)                                                                              \
     SUB(Service, SET)                                                                              \
     SUB(Service, SM)                                                                               \
     SUB(Service, SPL)                                                                              \
     SUB(Service, SSL)                                                                              \
-    SUB(Service, TCAP)                                                                             \
     SUB(Service, Time)                                                                             \
     SUB(Service, USB)                                                                              \
     SUB(Service, VI)                                                                               \

src/common/logging/backend.h

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

src/common/logging/log.h

@@ -83,7 +83,6 @@ enum class Class : ClassType {
     Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NIM,       ///< The NIM service
-    Service_NPNS,      ///< The NPNS service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCIE,      ///< The PCIe service
@@ -92,12 +91,10 @@ enum class Class : ClassType {
     Service_PM,        ///< The PM service
     Service_PREPO,     ///< The PREPO (Play report) service
     Service_PSC,       ///< The PSC service
-    Service_PSM,       ///< The PSM service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
     Service_SPL,       ///< The SPL service
     Service_SSL,       ///< The SSL service
-    Service_TCAP,      ///< The TCAP service.
     Service_Time,      ///< The time service
     Service_USB,       ///< The USB (Universal Serial Bus) service
     Service_VI,        ///< The VI (Video interface) service

src/common/logging/text_formatter.cpp

@@ -31,7 +31,7 @@ std::string FormatLogMessage(const Entry& entry) {
 }
 
 void PrintMessage(const Entry& entry) {
-    const auto str = FormatLogMessage(entry).append(1, '\n');
+    auto str = FormatLogMessage(entry) + '\n';
     fputs(str.c_str(), stderr);
 }
 

src/common/math_util.h

@@ -4,12 +4,18 @@
 
 #pragma once
 
+#include <algorithm>
 #include <cstdlib>
 #include <type_traits>
 
 namespace MathUtil {
 
-constexpr float PI = 3.14159265f;
+static constexpr float PI = 3.14159265f;
+
+inline bool IntervalsIntersect(unsigned start0, unsigned length0, unsigned start1,
+                               unsigned length1) {
+    return (std::max(start0, start1) < std::min(start0 + length0, start1 + length1));
+}
 
 template <class T>
 struct Rectangle {
@@ -18,16 +24,16 @@ struct Rectangle {
     T right{};
     T bottom{};
 
-    constexpr Rectangle() = default;
+    Rectangle() = default;
 
-    constexpr Rectangle(T left, T top, T right, T bottom)
+    Rectangle(T left, T top, T right, T bottom)
         : left(left), top(top), right(right), bottom(bottom) {}
 
     T GetWidth() const {
-        return std::abs(static_cast<std::make_signed_t<T>>(right - left));
+        return std::abs(static_cast<typename std::make_signed<T>::type>(right - left));
     }
     T GetHeight() const {
-        return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
+        return std::abs(static_cast<typename std::make_signed<T>::type>(bottom - top));
     }
     Rectangle<T> TranslateX(const T x) const {
         return Rectangle{left + x, top, right + x, bottom};

src/common/memory_util.cpp

@@ -0,0 +1,177 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "common/memory_util.h"
+
+#ifdef _WIN32
+#include <windows.h>
+// Windows.h needs to be included before psapi.h
+#include <psapi.h>
+#include "common/common_funcs.h"
+#include "common/string_util.h"
+#else
+#include <cstdlib>
+#include <sys/mman.h>
+#endif
+
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+#include <unistd.h>
+#define PAGE_MASK (getpagesize() - 1)
+#define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
+#endif
+
+// This is purposely not a full wrapper for virtualalloc/mmap, but it
+// provides exactly the primitive operations that Dolphin needs.
+
+void* AllocateExecutableMemory(std::size_t size, bool low) {
+#if defined(_WIN32)
+    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+#else
+    static char* map_hint = nullptr;
+#if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+    // This OS has no flag to enforce allocation below the 4 GB boundary,
+    // but if we hint that we want a low address it is very likely we will
+    // get one.
+    // An older version of this code used MAP_FIXED, but that has the side
+    // effect of discarding already mapped pages that happen to be in the
+    // requested virtual memory range (such as the emulated RAM, sometimes).
+    if (low && (!map_hint))
+        map_hint = (char*)round_page(512 * 1024 * 1024); /* 0.5 GB rounded up to the next page */
+#endif
+    void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
+                     MAP_ANON | MAP_PRIVATE
+#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
+                         | (low ? MAP_32BIT : 0)
+#endif
+                         ,
+                     -1, 0);
+#endif /* defined(_WIN32) */
+
+#ifdef _WIN32
+    if (ptr == nullptr) {
+#else
+    if (ptr == MAP_FAILED) {
+        ptr = nullptr;
+#endif
+        LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
+    }
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+    else {
+        if (low) {
+            map_hint += size;
+            map_hint = (char*)round_page(map_hint); /* round up to the next page */
+        }
+    }
+#endif
+
+#if EMU_ARCH_BITS == 64
+    if ((u64)ptr >= 0x80000000 && low == true)
+        LOG_ERROR(Common_Memory, "Executable memory ended up above 2GB!");
+#endif
+
+    return ptr;
+}
+
+void* AllocateMemoryPages(std::size_t size) {
+#ifdef _WIN32
+    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
+#else
+    void* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+
+    if (ptr == MAP_FAILED)
+        ptr = nullptr;
+#endif
+
+    if (ptr == nullptr)
+        LOG_ERROR(Common_Memory, "Failed to allocate raw memory");
+
+    return ptr;
+}
+
+void* AllocateAlignedMemory(std::size_t size, std::size_t alignment) {
+#ifdef _WIN32
+    void* ptr = _aligned_malloc(size, alignment);
+#else
+    void* ptr = nullptr;
+#ifdef ANDROID
+    ptr = memalign(alignment, size);
+#else
+    if (posix_memalign(&ptr, alignment, size) != 0)
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+#endif
+#endif
+
+    if (ptr == nullptr)
+        LOG_ERROR(Common_Memory, "Failed to allocate aligned memory");
+
+    return ptr;
+}
+
+void FreeMemoryPages(void* ptr, std::size_t size) {
+    if (ptr) {
+#ifdef _WIN32
+        if (!VirtualFree(ptr, 0, MEM_RELEASE))
+            LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
+#else
+        munmap(ptr, size);
+#endif
+    }
+}
+
+void FreeAlignedMemory(void* ptr) {
+    if (ptr) {
+#ifdef _WIN32
+        _aligned_free(ptr);
+#else
+        free(ptr);
+#endif
+    }
+}
+
+void WriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
+#ifdef _WIN32
+    DWORD oldValue;
+    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
+        LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
+#else
+    mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
+#endif
+}
+
+void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
+#ifdef _WIN32
+    DWORD oldValue;
+    if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,
+                        &oldValue))
+        LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
+#else
+    mprotect(ptr, size,
+             allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);
+#endif
+}
+
+std::string MemUsage() {
+#ifdef _WIN32
+#pragma comment(lib, "psapi")
+    DWORD processID = GetCurrentProcessId();
+    HANDLE hProcess;
+    PROCESS_MEMORY_COUNTERS pmc;
+    std::string Ret;
+
+    // Print information about the memory usage of the process.
+
+    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);
+    if (nullptr == hProcess)
+        return "MemUsage Error";
+
+    if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
+        Ret = fmt::format("{} K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7));
+
+    CloseHandle(hProcess);
+    return Ret;
+#else
+    return "";
+#endif
+}

src/common/memory_util.h

@@ -0,0 +1,21 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstddef>
+#include <string>
+
+void* AllocateExecutableMemory(std::size_t size, bool low = true);
+void* AllocateMemoryPages(std::size_t size);
+void FreeMemoryPages(void* ptr, std::size_t size);
+void* AllocateAlignedMemory(std::size_t size, std::size_t alignment);
+void FreeAlignedMemory(void* ptr);
+void WriteProtectMemory(void* ptr, std::size_t size, bool executable = false);
+void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute = false);
+std::string MemUsage();
+
+inline int GetPageSize() {
+    return 4096;
+}

src/common/param_package.cpp

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

src/common/param_package.h

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

src/common/string_util.cpp

@@ -4,16 +4,20 @@
 
 #include <algorithm>
 #include <cctype>
-#include <codecvt>
+#include <cerrno>
+#include <cstdio>
 #include <cstdlib>
-#include <locale>
-#include <sstream>
+#include <cstring>
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 
 #ifdef _WIN32
+#include <codecvt>
 #include <windows.h>
+#include "common/common_funcs.h"
+#else
+#include <iconv.h>
 #endif
 
 namespace Common {
@@ -32,6 +36,24 @@ std::string ToUpper(std::string str) {
     return str;
 }
 
+// For Debugging. Read out an u8 array.
+std::string ArrayToString(const u8* data, std::size_t size, int line_len, bool spaces) {
+    std::ostringstream oss;
+    oss << std::setfill('0') << std::hex;
+
+    for (int line = 0; size; ++data, --size) {
+        oss << std::setw(2) << (int)*data;
+
+        if (line_len == ++line) {
+            oss << '\n';
+            line = 0;
+        } else if (spaces)
+            oss << ' ';
+    }
+
+    return oss.str();
+}
+
 std::string StringFromBuffer(const std::vector<u8>& data) {
     return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
 }
@@ -56,6 +78,40 @@ std::string StripQuotes(const std::string& s) {
         return s;
 }
 
+bool TryParse(const std::string& str, u32* const output) {
+    char* endptr = nullptr;
+
+    // Reset errno to a value other than ERANGE
+    errno = 0;
+
+    unsigned long value = strtoul(str.c_str(), &endptr, 0);
+
+    if (!endptr || *endptr)
+        return false;
+
+    if (errno == ERANGE)
+        return false;
+
+#if ULONG_MAX > UINT_MAX
+    if (value >= 0x100000000ull && value <= 0xFFFFFFFF00000000ull)
+        return false;
+#endif
+
+    *output = static_cast<u32>(value);
+    return true;
+}
+
+bool TryParse(const std::string& str, bool* const output) {
+    if ("1" == str || "true" == ToLower(str))
+        *output = true;
+    else if ("0" == str || "false" == ToLower(str))
+        *output = false;
+    else
+        return false;
+
+    return true;
+}
+
 std::string StringFromBool(bool value) {
     return value ? "True" : "False";
 }
@@ -139,9 +195,11 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
     return result;
 }
 
+#ifdef _WIN32
+
 std::string UTF16ToUTF8(const std::u16string& input) {
-#ifdef _MSC_VER
-    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
+#if _MSC_VER >= 1900
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2015
     std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
     std::basic_string<__int16> tmp_buffer(input.cbegin(), input.cend());
     return convert.to_bytes(tmp_buffer);
@@ -152,8 +210,8 @@ std::string UTF16ToUTF8(const std::u16string& input) {
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
-#ifdef _MSC_VER
-    // Workaround for missing char16_t/char32_t instantiations in MSVC2017
+#if _MSC_VER >= 1900
+    // Workaround for missing char16_t/char32_t instantiations in MSVC2015
     std::wstring_convert<std::codecvt_utf8_utf16<__int16>, __int16> convert;
     auto tmp_buffer = convert.from_bytes(input);
     return std::u16string(tmp_buffer.cbegin(), tmp_buffer.cend());
@@ -163,7 +221,6 @@ std::u16string UTF8ToUTF16(const std::string& input) {
 #endif
 }
 
-#ifdef _WIN32
 static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
     const auto size =
         MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
@@ -204,6 +261,124 @@ std::wstring UTF8ToUTF16W(const std::string& input) {
     return CPToUTF16(CP_UTF8, input);
 }
 
+std::string SHIFTJISToUTF8(const std::string& input) {
+    return UTF16ToUTF8(CPToUTF16(932, input));
+}
+
+std::string CP1252ToUTF8(const std::string& input) {
+    return UTF16ToUTF8(CPToUTF16(1252, input));
+}
+
+#else
+
+template <typename T>
+static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input) {
+    iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
+    if ((iconv_t)(-1) == conv_desc) {
+        LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
+        iconv_close(conv_desc);
+        return {};
+    }
+
+    const std::size_t in_bytes = sizeof(T) * input.size();
+    // Multiply by 4, which is the max number of bytes to encode a codepoint
+    const std::size_t out_buffer_size = 4 * in_bytes;
+
+    std::string out_buffer(out_buffer_size, '\0');
+
+    auto src_buffer = &input[0];
+    std::size_t src_bytes = in_bytes;
+    auto dst_buffer = &out_buffer[0];
+    std::size_t dst_bytes = out_buffer.size();
+
+    while (0 != src_bytes) {
+        std::size_t const iconv_result =
+            iconv(conv_desc, (char**)(&src_buffer), &src_bytes, &dst_buffer, &dst_bytes);
+
+        if (static_cast<std::size_t>(-1) == iconv_result) {
+            if (EILSEQ == errno || EINVAL == errno) {
+                // Try to skip the bad character
+                if (0 != src_bytes) {
+                    --src_bytes;
+                    ++src_buffer;
+                }
+            } else {
+                LOG_ERROR(Common, "iconv failure [{}]: {}", fromcode, strerror(errno));
+                break;
+            }
+        }
+    }
+
+    std::string result;
+    out_buffer.resize(out_buffer_size - dst_bytes);
+    out_buffer.swap(result);
+
+    iconv_close(conv_desc);
+
+    return result;
+}
+
+std::u16string UTF8ToUTF16(const std::string& input) {
+    iconv_t const conv_desc = iconv_open("UTF-16LE", "UTF-8");
+    if ((iconv_t)(-1) == conv_desc) {
+        LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
+        iconv_close(conv_desc);
+        return {};
+    }
+
+    const std::size_t in_bytes = sizeof(char) * input.size();
+    // Multiply by 4, which is the max number of bytes to encode a codepoint
+    const std::size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
+
+    std::u16string out_buffer(out_buffer_size, char16_t{});
+
+    char* src_buffer = const_cast<char*>(&input[0]);
+    std::size_t src_bytes = in_bytes;
+    char* dst_buffer = (char*)(&out_buffer[0]);
+    std::size_t dst_bytes = out_buffer.size();
+
+    while (0 != src_bytes) {
+        std::size_t const iconv_result =
+            iconv(conv_desc, &src_buffer, &src_bytes, &dst_buffer, &dst_bytes);
+
+        if (static_cast<std::size_t>(-1) == iconv_result) {
+            if (EILSEQ == errno || EINVAL == errno) {
+                // Try to skip the bad character
+                if (0 != src_bytes) {
+                    --src_bytes;
+                    ++src_buffer;
+                }
+            } else {
+                LOG_ERROR(Common, "iconv failure [UTF-8]: {}", strerror(errno));
+                break;
+            }
+        }
+    }
+
+    std::u16string result;
+    out_buffer.resize(out_buffer_size - dst_bytes);
+    out_buffer.swap(result);
+
+    iconv_close(conv_desc);
+
+    return result;
+}
+
+std::string UTF16ToUTF8(const std::u16string& input) {
+    return CodeToUTF8("UTF-16LE", input);
+}
+
+std::string CP1252ToUTF8(const std::string& input) {
+    // return CodeToUTF8("CP1252//TRANSLIT", input);
+    // return CodeToUTF8("CP1252//IGNORE", input);
+    return CodeToUTF8("CP1252", input);
+}
+
+std::string SHIFTJISToUTF8(const std::string& input) {
+    // return CodeToUTF8("CP932", input);
+    return CodeToUTF8("SJIS", input);
+}
+
 #endif
 
 std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t max_len) {
@@ -214,15 +389,6 @@ std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t
     return std::string(buffer, len);
 }
 
-std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
-                                                        std::size_t max_len) {
-    std::size_t len = 0;
-    while (len < max_len && buffer[len] != '\0')
-        ++len;
-
-    return std::u16string(buffer.begin(), buffer.begin() + len);
-}
-
 const char* TrimSourcePath(const char* path, const char* root) {
     const char* p = path;
 

src/common/string_util.h

@@ -5,6 +5,8 @@
 #pragma once
 
 #include <cstddef>
+#include <iomanip>
+#include <sstream>
 #include <string>
 #include <vector>
 #include "common/common_types.h"
@@ -17,13 +19,44 @@ std::string ToLower(std::string str);
 /// Make a string uppercase
 std::string ToUpper(std::string str);
 
+std::string ArrayToString(const u8* data, std::size_t size, int line_len = 20, bool spaces = true);
+
 std::string StringFromBuffer(const std::vector<u8>& data);
 
 std::string StripSpaces(const std::string& s);
 std::string StripQuotes(const std::string& s);
 
+// Thousand separator. Turns 12345678 into 12,345,678
+template <typename I>
+std::string ThousandSeparate(I value, int spaces = 0) {
+    std::ostringstream oss;
+
+// std::locale("") seems to be broken on many platforms
+#if defined _WIN32 || (defined __linux__ && !defined __clang__)
+    oss.imbue(std::locale(""));
+#endif
+    oss << std::setw(spaces) << value;
+
+    return oss.str();
+}
+
 std::string StringFromBool(bool value);
 
+bool TryParse(const std::string& str, bool* output);
+bool TryParse(const std::string& str, u32* output);
+
+template <typename N>
+static bool TryParse(const std::string& str, N* const output) {
+    std::istringstream iss(str);
+
+    N tmp = 0;
+    if (iss >> tmp) {
+        *output = tmp;
+        return true;
+    } else
+        return false;
+}
+
 std::string TabsToSpaces(int tab_size, std::string in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
@@ -39,10 +72,31 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 std::string UTF16ToUTF8(const std::u16string& input);
 std::u16string UTF8ToUTF16(const std::string& input);
 
+std::string CP1252ToUTF8(const std::string& str);
+std::string SHIFTJISToUTF8(const std::string& str);
+
 #ifdef _WIN32
 std::string UTF16ToUTF8(const std::wstring& input);
 std::wstring UTF8ToUTF16W(const std::string& str);
 
+#ifdef _UNICODE
+inline std::string TStrToUTF8(const std::wstring& str) {
+    return UTF16ToUTF8(str);
+}
+
+inline std::wstring UTF8ToTStr(const std::string& str) {
+    return UTF8ToUTF16W(str);
+}
+#else
+inline std::string TStrToUTF8(const std::string& str) {
+    return str;
+}
+
+inline std::string UTF8ToTStr(const std::string& str) {
+    return str;
+}
+#endif
+
 #endif
 
 /**
@@ -66,14 +120,6 @@ bool ComparePartialString(InIt begin, InIt end, const char* other) {
  */
 std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t max_len);
 
-/**
- * Creates a UTF-16 std::u16string from a fixed-size NUL-terminated char buffer. If the buffer isn't
- * null-terminated, then the string ends at the greatest multiple of two less then or equal to
- * max_len_bytes.
- */
-std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
-                                                        std::size_t max_len);
-
 /**
  * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
  * intended to be used to strip a system-specific build directory from the `__FILE__` macro,

src/common/telemetry.h

@@ -153,7 +153,6 @@ struct VisitorInterface : NonCopyable {
 
     /// Completion method, called once all fields have been visited
     virtual void Complete() = 0;
-    virtual bool SubmitTestcase() = 0;
 };
 
 /**
@@ -179,9 +178,6 @@ struct NullVisitor : public VisitorInterface {
     void Visit(const Field<std::chrono::microseconds>& /*field*/) override {}
 
     void Complete() override {}
-    bool SubmitTestcase() override {
-        return false;
-    }
 };
 
 /// Appends build-specific information to the given FieldCollection,

src/common/thread.cpp

@@ -25,6 +25,23 @@
 
 namespace Common {
 
+int CurrentThreadId() {
+#ifdef _MSC_VER
+    return GetCurrentThreadId();
+#elif defined __APPLE__
+    return mach_thread_self();
+#else
+    return 0;
+#endif
+}
+
+#ifdef _WIN32
+// Supporting functions
+void SleepCurrentThread(int ms) {
+    Sleep(ms);
+}
+#endif
+
 #ifdef _MSC_VER
 
 void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask) {
@@ -45,7 +62,7 @@ void SwitchCurrentThread() {
 
 // This is implemented much nicer in upcoming msvc++, see:
 // http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
-void SetCurrentThreadName(const char* name) {
+void SetCurrentThreadName(const char* szThreadName) {
     static const DWORD MS_VC_EXCEPTION = 0x406D1388;
 
 #pragma pack(push, 8)
@@ -58,7 +75,7 @@ void SetCurrentThreadName(const char* name) {
 #pragma pack(pop)
 
     info.dwType = 0x1000;
-    info.szName = name;
+    info.szName = szThreadName;
     info.dwThreadID = -1; // dwThreadID;
     info.dwFlags = 0;
 
@@ -90,6 +107,10 @@ void SetCurrentThreadAffinity(u32 mask) {
 }
 
 #ifndef _WIN32
+void SleepCurrentThread(int ms) {
+    usleep(1000 * ms);
+}
+
 void SwitchCurrentThread() {
     usleep(1000 * 1);
 }
@@ -97,15 +118,15 @@ void SwitchCurrentThread() {
 
 // MinGW with the POSIX threading model does not support pthread_setname_np
 #if !defined(_WIN32) || defined(_MSC_VER)
-void SetCurrentThreadName(const char* name) {
+void SetCurrentThreadName(const char* szThreadName) {
 #ifdef __APPLE__
-    pthread_setname_np(name);
+    pthread_setname_np(szThreadName);
 #elif defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-    pthread_set_name_np(pthread_self(), name);
+    pthread_set_name_np(pthread_self(), szThreadName);
 #elif defined(__NetBSD__)
-    pthread_setname_np(pthread_self(), "%s", (void*)name);
+    pthread_setname_np(pthread_self(), "%s", (void*)szThreadName);
 #else
-    pthread_setname_np(pthread_self(), name);
+    pthread_setname_np(pthread_self(), szThreadName);
 #endif
 }
 #endif

src/common/thread.h

@@ -13,8 +13,15 @@
 
 namespace Common {
 
+int CurrentThreadId();
+
+void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
+void SetCurrentThreadAffinity(u32 mask);
+
 class Event {
 public:
+    Event() : is_set(false) {}
+
     void Set() {
         std::lock_guard<std::mutex> lk(mutex);
         if (!is_set) {
@@ -46,14 +53,14 @@ public:
     }
 
 private:
-    bool is_set = false;
+    bool is_set;
     std::condition_variable condvar;
     std::mutex mutex;
 };
 
 class Barrier {
 public:
-    explicit Barrier(std::size_t count_) : count(count_) {}
+    explicit Barrier(std::size_t count_) : count(count_), waiting(0), generation(0) {}
 
     /// Blocks until all "count" threads have called Sync()
     void Sync() {
@@ -73,13 +80,12 @@ public:
 private:
     std::condition_variable condvar;
     std::mutex mutex;
-    std::size_t count;
-    std::size_t waiting = 0;
-    std::size_t generation = 0; // Incremented once each time the barrier is used
+    const std::size_t count;
+    std::size_t waiting;
+    std::size_t generation; // Incremented once each time the barrier is used
 };
 
-void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
-void SetCurrentThreadAffinity(u32 mask);
+void SleepCurrentThread(int ms);
 void SwitchCurrentThread(); // On Linux, this is equal to sleep 1ms
 void SetCurrentThreadName(const char* name);
 

src/common/web_result.h

@@ -1,25 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include "common/common_types.h"
-
-namespace Common {
-struct WebResult {
-    enum class Code : u32 {
-        Success,
-        InvalidURL,
-        CredentialsMissing,
-        LibError,
-        HttpError,
-        WrongContent,
-        NoWebservice,
-    };
-    Code result_code;
-    std::string result_string;
-    std::string returned_data;
-};
-} // namespace Common

src/common/x64/xbyak_abi.h

@@ -0,0 +1,222 @@
+// Copyright 2016 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <initializer_list>
+#include <xbyak.h>
+#include "common/assert.h"
+#include "common/bit_set.h"
+
+namespace Common::X64 {
+
+inline int RegToIndex(const Xbyak::Reg& reg) {
+    using Kind = Xbyak::Reg::Kind;
+    ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
+               "RegSet only support GPRs and XMM registers.");
+    ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
+    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
+}
+
+inline Xbyak::Reg64 IndexToReg64(int reg_index) {
+    ASSERT(reg_index < 16);
+    return Xbyak::Reg64(reg_index);
+}
+
+inline Xbyak::Xmm IndexToXmm(int reg_index) {
+    ASSERT(reg_index >= 16 && reg_index < 32);
+    return Xbyak::Xmm(reg_index - 16);
+}
+
+inline Xbyak::Reg IndexToReg(int reg_index) {
+    if (reg_index < 16) {
+        return IndexToReg64(reg_index);
+    } else {
+        return IndexToXmm(reg_index);
+    }
+}
+
+inline BitSet32 BuildRegSet(std::initializer_list<Xbyak::Reg> regs) {
+    BitSet32 bits;
+    for (const Xbyak::Reg& reg : regs) {
+        bits[RegToIndex(reg)] = true;
+    }
+    return bits;
+}
+
+const BitSet32 ABI_ALL_GPRS(0x0000FFFF);
+const BitSet32 ABI_ALL_XMMS(0xFFFF0000);
+
+#ifdef _WIN32
+
+// Microsoft x64 ABI
+const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
+const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rcx;
+const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rdx;
+const Xbyak::Reg ABI_PARAM3 = Xbyak::util::r8;
+const Xbyak::Reg ABI_PARAM4 = Xbyak::util::r9;
+
+const BitSet32 ABI_ALL_CALLER_SAVED = BuildRegSet({
+    // GPRs
+    Xbyak::util::rcx,
+    Xbyak::util::rdx,
+    Xbyak::util::r8,
+    Xbyak::util::r9,
+    Xbyak::util::r10,
+    Xbyak::util::r11,
+    // XMMs
+    Xbyak::util::xmm0,
+    Xbyak::util::xmm1,
+    Xbyak::util::xmm2,
+    Xbyak::util::xmm3,
+    Xbyak::util::xmm4,
+    Xbyak::util::xmm5,
+});
+
+const BitSet32 ABI_ALL_CALLEE_SAVED = BuildRegSet({
+    // GPRs
+    Xbyak::util::rbx,
+    Xbyak::util::rsi,
+    Xbyak::util::rdi,
+    Xbyak::util::rbp,
+    Xbyak::util::r12,
+    Xbyak::util::r13,
+    Xbyak::util::r14,
+    Xbyak::util::r15,
+    // XMMs
+    Xbyak::util::xmm6,
+    Xbyak::util::xmm7,
+    Xbyak::util::xmm8,
+    Xbyak::util::xmm9,
+    Xbyak::util::xmm10,
+    Xbyak::util::xmm11,
+    Xbyak::util::xmm12,
+    Xbyak::util::xmm13,
+    Xbyak::util::xmm14,
+    Xbyak::util::xmm15,
+});
+
+constexpr std::size_t ABI_SHADOW_SPACE = 0x20;
+
+#else
+
+// System V x86-64 ABI
+const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
+const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rdi;
+const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rsi;
+const Xbyak::Reg ABI_PARAM3 = Xbyak::util::rdx;
+const Xbyak::Reg ABI_PARAM4 = Xbyak::util::rcx;
+
+const BitSet32 ABI_ALL_CALLER_SAVED = BuildRegSet({
+    // GPRs
+    Xbyak::util::rcx,
+    Xbyak::util::rdx,
+    Xbyak::util::rdi,
+    Xbyak::util::rsi,
+    Xbyak::util::r8,
+    Xbyak::util::r9,
+    Xbyak::util::r10,
+    Xbyak::util::r11,
+    // XMMs
+    Xbyak::util::xmm0,
+    Xbyak::util::xmm1,
+    Xbyak::util::xmm2,
+    Xbyak::util::xmm3,
+    Xbyak::util::xmm4,
+    Xbyak::util::xmm5,
+    Xbyak::util::xmm6,
+    Xbyak::util::xmm7,
+    Xbyak::util::xmm8,
+    Xbyak::util::xmm9,
+    Xbyak::util::xmm10,
+    Xbyak::util::xmm11,
+    Xbyak::util::xmm12,
+    Xbyak::util::xmm13,
+    Xbyak::util::xmm14,
+    Xbyak::util::xmm15,
+});
+
+const BitSet32 ABI_ALL_CALLEE_SAVED = BuildRegSet({
+    // GPRs
+    Xbyak::util::rbx,
+    Xbyak::util::rbp,
+    Xbyak::util::r12,
+    Xbyak::util::r13,
+    Xbyak::util::r14,
+    Xbyak::util::r15,
+});
+
+constexpr std::size_t ABI_SHADOW_SPACE = 0;
+
+#endif
+
+inline void ABI_CalculateFrameSize(BitSet32 regs, std::size_t rsp_alignment,
+                                   std::size_t needed_frame_size, s32* out_subtraction,
+                                   s32* out_xmm_offset) {
+    int count = (regs & ABI_ALL_GPRS).Count();
+    rsp_alignment -= count * 8;
+    std::size_t subtraction = 0;
+    int xmm_count = (regs & ABI_ALL_XMMS).Count();
+    if (xmm_count) {
+        // If we have any XMMs to save, we must align the stack here.
+        subtraction = rsp_alignment & 0xF;
+    }
+    subtraction += 0x10 * xmm_count;
+    std::size_t xmm_base_subtraction = subtraction;
+    subtraction += needed_frame_size;
+    subtraction += ABI_SHADOW_SPACE;
+    // Final alignment.
+    rsp_alignment -= subtraction;
+    subtraction += rsp_alignment & 0xF;
+
+    *out_subtraction = (s32)subtraction;
+    *out_xmm_offset = (s32)(subtraction - xmm_base_subtraction);
+}
+
+inline std::size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
+                                                   std::size_t rsp_alignment,
+                                                   std::size_t needed_frame_size = 0) {
+    s32 subtraction, xmm_offset;
+    ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
+
+    for (int reg_index : (regs & ABI_ALL_GPRS)) {
+        code.push(IndexToReg64(reg_index));
+    }
+
+    if (subtraction != 0) {
+        code.sub(code.rsp, subtraction);
+    }
+
+    for (int reg_index : (regs & ABI_ALL_XMMS)) {
+        code.movaps(code.xword[code.rsp + xmm_offset], IndexToXmm(reg_index));
+        xmm_offset += 0x10;
+    }
+
+    return ABI_SHADOW_SPACE;
+}
+
+inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
+                                           std::size_t rsp_alignment,
+                                           std::size_t needed_frame_size = 0) {
+    s32 subtraction, xmm_offset;
+    ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
+
+    for (int reg_index : (regs & ABI_ALL_XMMS)) {
+        code.movaps(IndexToXmm(reg_index), code.xword[code.rsp + xmm_offset]);
+        xmm_offset += 0x10;
+    }
+
+    if (subtraction != 0) {
+        code.add(code.rsp, subtraction);
+    }
+
+    // GPRs need to be popped in reverse order
+    for (int reg_index = 15; reg_index >= 0; reg_index--) {
+        if (regs[reg_index]) {
+            code.pop(IndexToReg64(reg_index));
+        }
+    }
+}
+
+} // namespace Common::X64

src/common/x64/xbyak_util.h

@@ -0,0 +1,47 @@
+// Copyright 2016 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <type_traits>
+#include <xbyak.h>
+#include "common/x64/xbyak_abi.h"
+
+namespace Common::X64 {
+
+// Constants for use with cmpps/cmpss
+enum {
+    CMP_EQ = 0,
+    CMP_LT = 1,
+    CMP_LE = 2,
+    CMP_UNORD = 3,
+    CMP_NEQ = 4,
+    CMP_NLT = 5,
+    CMP_NLE = 6,
+    CMP_ORD = 7,
+};
+
+inline bool IsWithin2G(uintptr_t ref, uintptr_t target) {
+    u64 distance = target - (ref + 5);
+    return !(distance >= 0x8000'0000ULL && distance <= ~0x8000'0000ULL);
+}
+
+inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
+    return IsWithin2G(reinterpret_cast<uintptr_t>(code.getCurr()), target);
+}
+
+template <typename T>
+inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
+    static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
+    std::size_t addr = reinterpret_cast<std::size_t>(f);
+    if (IsWithin2G(code, addr)) {
+        code.call(f);
+    } else {
+        // ABI_RETURN is a safe temp register to use before a call
+        code.mov(ABI_RETURN, addr);
+        code.call(ABI_RETURN);
+    }
+}
+
+} // namespace Common::X64

src/core/CMakeLists.txt

@@ -12,16 +12,12 @@ add_library(core STATIC
     core_timing.h
     core_timing_util.cpp
     core_timing_util.h
-    cpu_core_manager.cpp
-    cpu_core_manager.h
     crypto/aes_util.cpp
     crypto/aes_util.h
     crypto/encryption_layer.cpp
     crypto/encryption_layer.h
     crypto/key_manager.cpp
     crypto/key_manager.h
-    crypto/partition_data_manager.cpp
-    crypto/partition_data_manager.h
     crypto/ctr_encryption_layer.cpp
     crypto/ctr_encryption_layer.h
     crypto/xts_encryption_layer.cpp
@@ -38,8 +34,6 @@ add_library(core STATIC
     file_sys/errors.h
     file_sys/fsmitm_romfsbuild.cpp
     file_sys/fsmitm_romfsbuild.h
-    file_sys/ips_layer.cpp
-    file_sys/ips_layer.h
     file_sys/mode.h
     file_sys/nca_metadata.cpp
     file_sys/nca_metadata.h
@@ -74,13 +68,10 @@ add_library(core STATIC
     file_sys/vfs_real.cpp
     file_sys/vfs_real.h
     file_sys/vfs_static.h
-    file_sys/vfs_types.h
     file_sys/vfs_vector.cpp
     file_sys/vfs_vector.h
     file_sys/xts_archive.cpp
     file_sys/xts_archive.h
-    frontend/applets/software_keyboard.cpp
-    frontend/applets/software_keyboard.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
@@ -154,20 +145,12 @@ add_library(core STATIC
     hle/service/am/applet_ae.h
     hle/service/am/applet_oe.cpp
     hle/service/am/applet_oe.h
-    hle/service/am/applets/applets.cpp
-    hle/service/am/applets/applets.h
-    hle/service/am/applets/software_keyboard.cpp
-    hle/service/am/applets/software_keyboard.h
-    hle/service/am/applets/stub_applet.cpp
-    hle/service/am/applets/stub_applet.h
     hle/service/am/idle.cpp
     hle/service/am/idle.h
     hle/service/am/omm.cpp
     hle/service/am/omm.h
     hle/service/am/spsm.cpp
     hle/service/am/spsm.h
-    hle/service/am/tcap.cpp
-    hle/service/am/tcap.h
     hle/service/aoc/aoc_u.cpp
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
@@ -248,24 +231,6 @@ add_library(core STATIC
     hle/service/hid/irs.h
     hle/service/hid/xcd.cpp
     hle/service/hid/xcd.h
-    hle/service/hid/controllers/controller_base.cpp
-    hle/service/hid/controllers/controller_base.h
-    hle/service/hid/controllers/debug_pad.cpp
-    hle/service/hid/controllers/debug_pad.h
-    hle/service/hid/controllers/gesture.cpp
-    hle/service/hid/controllers/gesture.h
-    hle/service/hid/controllers/keyboard.cpp
-    hle/service/hid/controllers/keyboard.h
-    hle/service/hid/controllers/mouse.cpp
-    hle/service/hid/controllers/mouse.h
-    hle/service/hid/controllers/npad.cpp
-    hle/service/hid/controllers/npad.h
-    hle/service/hid/controllers/stubbed.cpp
-    hle/service/hid/controllers/stubbed.h
-    hle/service/hid/controllers/touchscreen.cpp
-    hle/service/hid/controllers/touchscreen.h
-    hle/service/hid/controllers/xpad.cpp
-    hle/service/hid/controllers/xpad.h
     hle/service/lbl/lbl.cpp
     hle/service/lbl/lbl.h
     hle/service/ldn/ldn.cpp
@@ -292,8 +257,6 @@ add_library(core STATIC
     hle/service/nifm/nifm.h
     hle/service/nim/nim.cpp
     hle/service/nim/nim.h
-    hle/service/npns/npns.cpp
-    hle/service/npns/npns.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -341,8 +304,6 @@ add_library(core STATIC
     hle/service/prepo/prepo.h
     hle/service/psc/psc.cpp
     hle/service/psc/psc.h
-    hle/service/ptm/psm.cpp
-    hle/service/ptm/psm.h
     hle/service/service.cpp
     hle/service/service.h
     hle/service/set/set.cpp
@@ -433,10 +394,6 @@ create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
 target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn open_source_archives)
-if (ENABLE_WEB_SERVICE)
-    target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
-    target_link_libraries(core PRIVATE web_service)
-endif()
 
 if (ARCHITECTURE_x86_64)
     target_sources(core PRIVATE

src/core/arm/arm_interface.h

@@ -22,16 +22,10 @@ public:
         std::array<u64, 31> cpu_registers;
         u64 sp;
         u64 pc;
-        u32 pstate;
-        std::array<u8, 4> padding;
+        u64 pstate;
         std::array<u128, 32> vector_registers;
-        u32 fpcr;
-        u32 fpsr;
-        u64 tpidr;
+        u64 fpcr;
     };
-    // Internally within the kernel, it expects the AArch64 version of the
-    // thread context to be 800 bytes in size.
-    static_assert(sizeof(ThreadContext) == 0x320);
 
     /// Runs the CPU until an event happens
     virtual void Run() = 0;

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -86,7 +86,7 @@ public:
                 parent.jit->HaltExecution();
                 parent.SetPC(pc);
                 Kernel::Thread* thread = Kernel::GetCurrentThread();
-                parent.SaveContext(thread->GetContext());
+                parent.SaveContext(thread->context);
                 GDBStub::Break();
                 GDBStub::SendTrap(thread, 5);
                 return;
@@ -129,8 +129,7 @@ public:
 };
 
 std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
-    auto* current_process = Core::CurrentProcess();
-    auto** const page_table = current_process->VMManager().page_table.pointers.data();
+    auto** const page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
 
@@ -139,12 +138,12 @@ std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
 
     // Memory
     config.page_table = reinterpret_cast<void**>(page_table);
-    config.page_table_address_space_bits = current_process->VMManager().GetAddressSpaceWidth();
+    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
     config.silently_mirror_page_table = false;
 
     // Multi-process state
     config.processor_id = core_index;
-    config.global_monitor = &exclusive_monitor.monitor;
+    config.global_monitor = &exclusive_monitor->monitor;
 
     // System registers
     config.tpidrro_el0 = &cb->tpidrro_el0;
@@ -171,10 +170,11 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(ExclusiveMonitor& exclusive_monitor, std::size_t core_index)
+ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+                           std::size_t core_index)
     : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {
-    ThreadContext ctx{};
+      exclusive_monitor{std::dynamic_pointer_cast<DynarmicExclusiveMonitor>(exclusive_monitor)} {
+    ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     PageTableChanged();
     LoadContext(ctx);
@@ -246,19 +246,15 @@ void ARM_Dynarmic::SaveContext(ThreadContext& ctx) {
     ctx.pstate = jit->GetPstate();
     ctx.vector_registers = jit->GetVectors();
     ctx.fpcr = jit->GetFpcr();
-    ctx.fpsr = jit->GetFpsr();
-    ctx.tpidr = cb->tpidr_el0;
 }
 
 void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
     jit->SetRegisters(ctx.cpu_registers);
     jit->SetSP(ctx.sp);
     jit->SetPC(ctx.pc);
-    jit->SetPstate(ctx.pstate);
+    jit->SetPstate(static_cast<u32>(ctx.pstate));
     jit->SetVectors(ctx.vector_registers);
-    jit->SetFpcr(ctx.fpcr);
-    jit->SetFpsr(ctx.fpsr);
-    SetTPIDR_EL0(ctx.tpidr);
+    jit->SetFpcr(static_cast<u32>(ctx.fpcr));
 }
 
 void ARM_Dynarmic::PrepareReschedule() {

src/core/arm/dynarmic/arm_dynarmic.h

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

src/core/arm/unicorn/arm_unicorn.cpp

@@ -195,7 +195,7 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
             uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);
         }
         Kernel::Thread* thread = Kernel::GetCurrentThread();
-        SaveContext(thread->GetContext());
+        SaveContext(thread->context);
         if (last_bkpt_hit || GDBStub::GetCpuStepFlag()) {
             last_bkpt_hit = false;
             GDBStub::Break();

src/core/core.cpp

@@ -14,7 +14,6 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
-#include "core/cpu_core_manager.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
@@ -24,13 +23,12 @@
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
 #include "core/hle/service/service.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 "frontend/applets/software_keyboard.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/gpu.h"
 #include "video_core/renderer_base.h"
@@ -71,22 +69,64 @@ 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);
+    }
+}
 } // Anonymous namespace
 
 struct System::Impl {
     Cpu& CurrentCpuCore() {
-        return cpu_core_manager.GetCurrentCore();
+        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;
 
-        cpu_core_manager.RunLoop(tight_loop);
+        // 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(System& system, Frontend::EmuWindow& emu_window) {
+    ResultStatus Init(Frontend::EmuWindow& emu_window) {
         LOG_DEBUG(HW_Memory, "initialized OK");
 
         CoreTiming::Init();
@@ -96,17 +136,18 @@ struct System::Impl {
         if (virtual_filesystem == nullptr)
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
 
-        /// Create default implementations of applets if one is not provided.
-        if (software_keyboard == nullptr)
-            software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
+        kernel.MakeCurrentProcess(Kernel::Process::Create(kernel, "main"));
 
-        auto main_process = Kernel::Process::Create(kernel, "main");
-        kernel.MakeCurrentProcess(main_process.get());
+        cpu_barrier = std::make_shared<CpuBarrier>();
+        cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
+        for (std::size_t index = 0; index < cpu_cores.size(); ++index) {
+            cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
+        }
 
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-        Service::Init(service_manager, *virtual_filesystem);
+        Service::Init(service_manager, virtual_filesystem);
         GDBStub::Init();
 
         renderer = VideoCore::CreateRenderer(emu_window);
@@ -116,8 +157,17 @@ struct System::Impl {
 
         gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
 
-        cpu_core_manager.Initialize(system);
-        is_powered_on = true;
+        // 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 (std::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
@@ -127,15 +177,14 @@ struct System::Impl {
         return ResultStatus::Success;
     }
 
-    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
-                      const std::string& filepath) {
+    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<std::optional<u32>, Loader::ResultStatus> system_mode =
+        std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
             app_loader->LoadKernelSystemMode();
 
         if (system_mode.second != Loader::ResultStatus::Success) {
@@ -145,7 +194,7 @@ struct System::Impl {
             return ResultStatus::ErrorSystemMode;
         }
 
-        ResultStatus init_result{Init(system, emu_window)};
+        ResultStatus init_result{Init(emu_window)};
         if (init_result != ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                          static_cast<int>(init_result));
@@ -153,7 +202,7 @@ struct System::Impl {
             return init_result;
         }
 
-        const Loader::ResultStatus load_result{app_loader->Load(*kernel.CurrentProcess())};
+        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();
@@ -175,8 +224,6 @@ struct System::Impl {
         Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
                              perf_results.frametime * 1000.0);
 
-        is_powered_on = false;
-
         // Shutdown emulation session
         renderer.reset();
         GDBStub::Shutdown();
@@ -186,7 +233,18 @@ struct System::Impl {
         gpu_core.reset();
 
         // Close all CPU/threading state
-        cpu_core_manager.Shutdown();
+        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();
@@ -223,11 +281,11 @@ struct System::Impl {
     std::unique_ptr<VideoCore::RendererBase> renderer;
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
-    CpuCoreManager cpu_core_manager;
-    bool is_powered_on = false;
-
-    /// Frontend applets
-    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
+    std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
+    std::shared_ptr<CpuBarrier> cpu_barrier;
+    std::array<std::shared_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
+    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
+    std::size_t active_core{}; ///< Active core, only used in single thread mode
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -238,6 +296,9 @@ struct System::Impl {
     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;
 };
@@ -249,10 +310,6 @@ Cpu& System::CurrentCpuCore() {
     return impl->CurrentCpuCore();
 }
 
-const Cpu& System::CurrentCpuCore() const {
-    return impl->CurrentCpuCore();
-}
-
 System::ResultStatus System::RunLoop(bool tight_loop) {
     return impl->RunLoop(tight_loop);
 }
@@ -262,15 +319,17 @@ System::ResultStatus System::SingleStep() {
 }
 
 void System::InvalidateCpuInstructionCaches() {
-    impl->cpu_core_manager.InvalidateAllInstructionCaches();
+    for (auto& cpu : impl->cpu_cores) {
+        cpu->ArmInterface().ClearInstructionCache();
+    }
 }
 
 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    return impl->Load(*this, emu_window, filepath);
+    return impl->Load(emu_window, filepath);
 }
 
 bool System::IsPoweredOn() const {
-    return impl->is_powered_on;
+    return impl->cpu_barrier && impl->cpu_barrier->IsAlive();
 }
 
 void System::PrepareReschedule() {
@@ -281,11 +340,7 @@ PerfStatsResults System::GetAndResetPerfStats() {
     return impl->GetAndResetPerfStats();
 }
 
-TelemetrySession& System::TelemetrySession() {
-    return *impl->telemetry_session;
-}
-
-const TelemetrySession& System::TelemetrySession() const {
+Core::TelemetrySession& System::TelemetrySession() const {
     return *impl->telemetry_session;
 }
 
@@ -293,61 +348,39 @@ ARM_Interface& System::CurrentArmInterface() {
     return CurrentCpuCore().ArmInterface();
 }
 
-const ARM_Interface& System::CurrentArmInterface() const {
-    return CurrentCpuCore().ArmInterface();
-}
-
-std::size_t System::CurrentCoreIndex() const {
+std::size_t System::CurrentCoreIndex() {
     return CurrentCpuCore().CoreIndex();
 }
 
 Kernel::Scheduler& System::CurrentScheduler() {
-    return CurrentCpuCore().Scheduler();
+    return *CurrentCpuCore().Scheduler();
 }
 
-const Kernel::Scheduler& System::CurrentScheduler() const {
-    return CurrentCpuCore().Scheduler();
+const std::shared_ptr<Kernel::Scheduler>& System::Scheduler(std::size_t core_index) {
+    ASSERT(core_index < NUM_CPU_CORES);
+    return impl->cpu_cores[core_index]->Scheduler();
 }
 
-Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
-    return CpuCore(core_index).Scheduler();
-}
-
-const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
-    return CpuCore(core_index).Scheduler();
-}
-
-Kernel::Process* System::CurrentProcess() {
+Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() {
     return impl->kernel.CurrentProcess();
 }
 
-const Kernel::Process* System::CurrentProcess() const {
+const Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() const {
     return impl->kernel.CurrentProcess();
 }
 
 ARM_Interface& System::ArmInterface(std::size_t core_index) {
-    return CpuCore(core_index).ArmInterface();
-}
-
-const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
-    return CpuCore(core_index).ArmInterface();
+    ASSERT(core_index < NUM_CPU_CORES);
+    return impl->cpu_cores[core_index]->ArmInterface();
 }
 
 Cpu& System::CpuCore(std::size_t core_index) {
-    return impl->cpu_core_manager.GetCore(core_index);
-}
-
-const Cpu& System::CpuCore(std::size_t core_index) const {
     ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_core_manager.GetCore(core_index);
+    return *impl->cpu_cores[core_index];
 }
 
 ExclusiveMonitor& System::Monitor() {
-    return impl->cpu_core_manager.GetExclusiveMonitor();
-}
-
-const ExclusiveMonitor& System::Monitor() const {
-    return impl->cpu_core_manager.GetExclusiveMonitor();
+    return *impl->cpu_exclusive_monitor;
 }
 
 Tegra::GPU& System::GPU() {
@@ -422,16 +455,8 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
-void System::SetSoftwareKeyboard(std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> applet) {
-    impl->software_keyboard = std::move(applet);
-}
-
-const Core::Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
-    return *impl->software_keyboard;
-}
-
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(*this, emu_window);
+    return impl->Init(emu_window);
 }
 
 void System::Shutdown() {

src/core/core.h

@@ -13,7 +13,6 @@
 
 namespace Core::Frontend {
 class EmuWindow;
-class SoftwareKeyboardApplet;
 } // namespace Core::Frontend
 
 namespace FileSys {
@@ -130,11 +129,11 @@ public:
      */
     bool IsPoweredOn() const;
 
-    /// Gets a reference to the telemetry session for this emulation session.
-    Core::TelemetrySession& TelemetrySession();
-
-    /// Gets a reference to the telemetry session for this emulation session.
-    const Core::TelemetrySession& TelemetrySession() const;
+    /**
+     * Returns a reference to the telemetry session for this emulation session.
+     * @returns Reference to the telemetry session.
+     */
+    Core::TelemetrySession& TelemetrySession() const;
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
@@ -145,36 +144,21 @@ public:
     /// Gets an ARM interface to the CPU core that is currently running
     ARM_Interface& CurrentArmInterface();
 
-    /// Gets an ARM interface to the CPU core that is currently running
-    const ARM_Interface& CurrentArmInterface() const;
-
     /// Gets the index of the currently running CPU core
-    std::size_t CurrentCoreIndex() const;
+    std::size_t CurrentCoreIndex();
 
     /// Gets the scheduler for the CPU core that is currently running
     Kernel::Scheduler& CurrentScheduler();
 
-    /// Gets the scheduler for the CPU core that is currently running
-    const Kernel::Scheduler& CurrentScheduler() const;
-
-    /// Gets a reference to an ARM interface for the CPU core with the specified index
+    /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(std::size_t core_index);
 
-    /// Gets a const reference to an ARM interface from the CPU core with the specified index
-    const ARM_Interface& ArmInterface(std::size_t core_index) const;
-
     /// Gets a CPU interface to the CPU core with the specified index
     Cpu& CpuCore(std::size_t core_index);
 
-    /// Gets a CPU interface to the CPU core with the specified index
-    const Cpu& CpuCore(std::size_t core_index) const;
-
-    /// Gets a reference to the exclusive monitor
+    /// Gets the exclusive monitor
     ExclusiveMonitor& Monitor();
 
-    /// Gets a constant reference to the exclusive monitor
-    const ExclusiveMonitor& Monitor() const;
-
     /// Gets a mutable reference to the GPU interface
     Tegra::GPU& GPU();
 
@@ -188,16 +172,13 @@ public:
     const VideoCore::RendererBase& Renderer() const;
 
     /// Gets the scheduler for the CPU core with the specified index
-    Kernel::Scheduler& Scheduler(std::size_t core_index);
+    const std::shared_ptr<Kernel::Scheduler>& Scheduler(std::size_t core_index);
 
-    /// Gets the scheduler for the CPU core with the specified index
-    const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
+    /// Provides a reference to the current process
+    Kernel::SharedPtr<Kernel::Process>& CurrentProcess();
 
-    /// Provides a pointer to the current process
-    Kernel::Process* CurrentProcess();
-
-    /// Provides a constant pointer to the current process.
-    const Kernel::Process* CurrentProcess() const;
+    /// Provides a constant reference to the current process.
+    const Kernel::SharedPtr<Kernel::Process>& CurrentProcess() const;
 
     /// Provides a reference to the kernel instance.
     Kernel::KernelCore& Kernel();
@@ -237,19 +218,12 @@ public:
 
     std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
 
-    void SetSoftwareKeyboard(std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> applet);
-
-    const Core::Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
-
 private:
     System();
 
     /// Returns the currently running CPU core
     Cpu& CurrentCpuCore();
 
-    /// Returns the currently running CPU core
-    const Cpu& CurrentCpuCore() const;
-
     /**
      * Initialize the emulated system.
      * @param emu_window Reference to the host-system window used for video output and keyboard
@@ -272,7 +246,7 @@ inline TelemetrySession& Telemetry() {
     return System::GetInstance().TelemetrySession();
 }
 
-inline Kernel::Process* CurrentProcess() {
+inline Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
     return System::GetInstance().CurrentProcess();
 }
 

src/core/core_cpu.cpp

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

src/core/core_cpu.h

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

src/core/cpu_core_manager.cpp

@@ -1,142 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/arm/exclusive_monitor.h"
-#include "core/core.h"
-#include "core/core_cpu.h"
-#include "core/cpu_core_manager.h"
-#include "core/gdbstub/gdbstub.h"
-#include "core/settings.h"
-
-namespace Core {
-namespace {
-void RunCpuCore(const System& system, Cpu& cpu_state) {
-    while (system.IsPoweredOn()) {
-        cpu_state.RunLoop(true);
-    }
-}
-} // Anonymous namespace
-
-CpuCoreManager::CpuCoreManager() = default;
-CpuCoreManager::~CpuCoreManager() = default;
-
-void CpuCoreManager::Initialize(System& system) {
-    barrier = std::make_unique<CpuBarrier>();
-    exclusive_monitor = Cpu::MakeExclusiveMonitor(cores.size());
-
-    for (std::size_t index = 0; index < cores.size(); ++index) {
-        cores[index] = std::make_unique<Cpu>(*exclusive_monitor, *barrier, index);
-    }
-
-    // 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()] = cores[0].get();
-    if (!Settings::values.use_multi_core) {
-        return;
-    }
-
-    for (std::size_t index = 0; index < core_threads.size(); ++index) {
-        core_threads[index] = std::make_unique<std::thread>(RunCpuCore, std::cref(system),
-                                                            std::ref(*cores[index + 1]));
-        thread_to_cpu[core_threads[index]->get_id()] = cores[index + 1].get();
-    }
-}
-
-void CpuCoreManager::Shutdown() {
-    barrier->NotifyEnd();
-    if (Settings::values.use_multi_core) {
-        for (auto& thread : core_threads) {
-            thread->join();
-            thread.reset();
-        }
-    }
-
-    thread_to_cpu.clear();
-    for (auto& cpu_core : cores) {
-        cpu_core.reset();
-    }
-
-    exclusive_monitor.reset();
-    barrier.reset();
-}
-
-Cpu& CpuCoreManager::GetCore(std::size_t index) {
-    return *cores.at(index);
-}
-
-const Cpu& CpuCoreManager::GetCore(std::size_t index) const {
-    return *cores.at(index);
-}
-
-ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() {
-    return *exclusive_monitor;
-}
-
-const ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() const {
-    return *exclusive_monitor;
-}
-
-Cpu& CpuCoreManager::GetCurrentCore() {
-    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 *cores[active_core];
-}
-
-const Cpu& CpuCoreManager::GetCurrentCore() const {
-    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 *cores[active_core];
-}
-
-void CpuCoreManager::RunLoop(bool tight_loop) {
-    // Update thread_to_cpu in case Core 0 is run from a different host thread
-    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
-
-    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;
-            }
-        }
-    }
-
-    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-        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);
-    }
-}
-
-void CpuCoreManager::InvalidateAllInstructionCaches() {
-    for (auto& cpu : cores) {
-        cpu->ArmInterface().ClearInstructionCache();
-    }
-}
-
-} // namespace Core

src/core/cpu_core_manager.h

@@ -1,59 +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 <map>
-#include <memory>
-#include <thread>
-
-namespace Core {
-
-class Cpu;
-class CpuBarrier;
-class ExclusiveMonitor;
-class System;
-
-class CpuCoreManager {
-public:
-    CpuCoreManager();
-    CpuCoreManager(const CpuCoreManager&) = delete;
-    CpuCoreManager(CpuCoreManager&&) = delete;
-
-    ~CpuCoreManager();
-
-    CpuCoreManager& operator=(const CpuCoreManager&) = delete;
-    CpuCoreManager& operator=(CpuCoreManager&&) = delete;
-
-    void Initialize(System& system);
-    void Shutdown();
-
-    Cpu& GetCore(std::size_t index);
-    const Cpu& GetCore(std::size_t index) const;
-
-    Cpu& GetCurrentCore();
-    const Cpu& GetCurrentCore() const;
-
-    ExclusiveMonitor& GetExclusiveMonitor();
-    const ExclusiveMonitor& GetExclusiveMonitor() const;
-
-    void RunLoop(bool tight_loop);
-
-    void InvalidateAllInstructionCaches();
-
-private:
-    static constexpr std::size_t NUM_CPU_CORES = 4;
-
-    std::unique_ptr<ExclusiveMonitor> exclusive_monitor;
-    std::unique_ptr<CpuBarrier> barrier;
-    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cores;
-    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> core_threads;
-    std::size_t active_core{}; ///< Active core, only used in single thread mode
-
-    /// Map of guest threads to CPU cores
-    std::map<std::thread::id, Cpu*> thread_to_cpu;
-};
-
-} // namespace Core

src/core/crypto/key_manager.cpp

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

src/core/crypto/key_manager.h

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

src/core/crypto/partition_data_manager.cpp

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

src/core/crypto/partition_data_manager.h

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

src/core/file_sys/bis_factory.cpp

@@ -8,22 +8,21 @@
 
 namespace FileSys {
 
-BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_, VirtualDir dump_root_)
+BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_)
     : nand_root(std::move(nand_root_)), load_root(std::move(load_root_)),
-      dump_root(std::move(dump_root_)),
-      sysnand_cache(std::make_unique<RegisteredCache>(
+      sysnand_cache(std::make_shared<RegisteredCache>(
           GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
-      usrnand_cache(std::make_unique<RegisteredCache>(
+      usrnand_cache(std::make_shared<RegisteredCache>(
           GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))) {}
 
 BISFactory::~BISFactory() = default;
 
-RegisteredCache* BISFactory::GetSystemNANDContents() const {
-    return sysnand_cache.get();
+std::shared_ptr<RegisteredCache> BISFactory::GetSystemNANDContents() const {
+    return sysnand_cache;
 }
 
-RegisteredCache* BISFactory::GetUserNANDContents() const {
-    return usrnand_cache.get();
+std::shared_ptr<RegisteredCache> BISFactory::GetUserNANDContents() const {
+    return usrnand_cache;
 }
 
 VirtualDir BISFactory::GetModificationLoadRoot(u64 title_id) const {
@@ -33,10 +32,4 @@ VirtualDir BISFactory::GetModificationLoadRoot(u64 title_id) const {
     return GetOrCreateDirectoryRelative(load_root, fmt::format("/{:016X}", title_id));
 }
 
-VirtualDir BISFactory::GetModificationDumpRoot(u64 title_id) const {
-    if (title_id == 0)
-        return nullptr;
-    return GetOrCreateDirectoryRelative(dump_root, fmt::format("/{:016X}", title_id));
-}
-
 } // namespace FileSys

src/core/file_sys/bis_factory.h

@@ -17,22 +17,20 @@ class RegisteredCache;
 /// registered caches.
 class BISFactory {
 public:
-    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root, VirtualDir dump_root);
+    explicit BISFactory(VirtualDir nand_root, VirtualDir load_root);
     ~BISFactory();
 
-    RegisteredCache* GetSystemNANDContents() const;
-    RegisteredCache* GetUserNANDContents() const;
+    std::shared_ptr<RegisteredCache> GetSystemNANDContents() const;
+    std::shared_ptr<RegisteredCache> GetUserNANDContents() const;
 
     VirtualDir GetModificationLoadRoot(u64 title_id) const;
-    VirtualDir GetModificationDumpRoot(u64 title_id) const;
 
 private:
     VirtualDir nand_root;
     VirtualDir load_root;
-    VirtualDir dump_root;
 
-    std::unique_ptr<RegisteredCache> sysnand_cache;
-    std::unique_ptr<RegisteredCache> usrnand_cache;
+    std::shared_ptr<RegisteredCache> sysnand_cache;
+    std::shared_ptr<RegisteredCache> usrnand_cache;
 };
 
 } // namespace FileSys

src/core/file_sys/card_image.cpp

@@ -20,9 +20,7 @@ namespace FileSys {
 
 constexpr std::array<const char*, 0x4> partition_names = {"update", "normal", "secure", "logo"};
 
-XCI::XCI(VirtualFile file_)
-    : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(0x4) {
+XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
         status = Loader::ResultStatus::ErrorBadXCIHeader;
         return;
@@ -122,16 +120,14 @@ u64 XCI::GetProgramTitleID() const {
     return secure_partition->GetProgramTitleID();
 }
 
-bool XCI::HasProgramNCA() const {
-    return program != nullptr;
+std::shared_ptr<NCA> XCI::GetProgramNCA() const {
+    return program;
 }
 
 VirtualFile XCI::GetProgramNCAFile() const {
-    if (!HasProgramNCA()) {
+    if (GetProgramNCA() == nullptr)
         return nullptr;
-    }
-
-    return program->GetBaseFile();
+    return GetProgramNCA()->GetBaseFile();
 }
 
 const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
@@ -168,6 +164,10 @@ VirtualDir XCI::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     if (partitions[static_cast<std::size_t>(part)] == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;
@@ -176,7 +176,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     for (const VirtualFile& file : partitions[static_cast<std::size_t>(part)]->GetFiles()) {
         if (file->GetExtension() != "nca")
             continue;
-        auto nca = std::make_shared<NCA>(file, nullptr, 0, keys);
+        auto nca = std::make_shared<NCA>(file);
         // TODO(DarkLordZach): Add proper Rev1+ Support
         if (nca->IsUpdate())
             continue;

src/core/file_sys/card_image.h

@@ -9,7 +9,6 @@
 #include <vector>
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/crypto/key_manager.h"
 #include "core/file_sys/vfs.h"
 
 namespace Loader {
@@ -32,18 +31,7 @@ enum class GamecardSize : u8 {
 };
 
 struct GamecardInfo {
-    u64_le firmware_version;
-    u32_le access_control_flags;
-    u32_le read_wait_time1;
-    u32_le read_wait_time2;
-    u32_le write_wait_time1;
-    u32_le write_wait_time2;
-    u32_le firmware_mode;
-    u32_le cup_version;
-    std::array<u8, 4> reserved1;
-    u64_le update_partition_hash;
-    u64_le cup_id;
-    std::array<u8, 0x38> reserved2;
+    std::array<u8, 0x70> data;
 };
 static_assert(sizeof(GamecardInfo) == 0x70, "GamecardInfo has incorrect size.");
 
@@ -92,7 +80,7 @@ public:
 
     u64 GetProgramTitleID() const;
 
-    bool HasProgramNCA() const;
+    std::shared_ptr<NCA> GetProgramNCA() const;
     VirtualFile GetProgramNCAFile() const;
     const std::vector<std::shared_ptr<NCA>>& GetNCAs() const;
     std::shared_ptr<NCA> GetNCAByType(NCAContentType type) const;
@@ -106,6 +94,9 @@ public:
 
     VirtualDir GetParentDirectory() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     Loader::ResultStatus AddNCAFromPartition(XCIPartition part);
 
@@ -119,7 +110,5 @@ private:
     std::shared_ptr<NSP> secure_partition;
     std::shared_ptr<NCA> program;
     std::vector<std::shared_ptr<NCA>> ncas;
-
-    Core::Crypto::KeyManager keys;
 };
 } // namespace FileSys

src/core/file_sys/content_archive.cpp

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

src/core/file_sys/content_archive.h

@@ -6,10 +6,9 @@
 
 #include <array>
 #include <memory>
-#include <optional>
 #include <string>
 #include <vector>
-
+#include <boost/optional.hpp>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -74,13 +73,14 @@ inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
 
+bool IsValidNCA(const NCAHeader& header);
+
 // An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
 public:
     explicit NCA(VirtualFile file, VirtualFile bktr_base_romfs = nullptr,
-                 u64 bktr_base_ivfc_offset = 0,
-                 Core::Crypto::KeyManager keys = Core::Crypto::KeyManager());
+                 u64 bktr_base_ivfc_offset = 0);
     ~NCA() override;
 
     Loader::ResultStatus GetStatus() const;
@@ -102,20 +102,14 @@ public:
     // Returns the base ivfc offset used in BKTR patching.
     u64 GetBaseIVFCOffset() const;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
-    bool CheckSupportedNCA(const NCAHeader& header);
-    bool HandlePotentialHeaderDecryption();
-
-    std::vector<NCASectionHeader> ReadSectionHeaders() const;
-    bool ReadSections(const std::vector<NCASectionHeader>& sections, u64 bktr_base_ivfc_offset);
-    bool ReadRomFSSection(const NCASectionHeader& section, const NCASectionTableEntry& entry,
-                          u64 bktr_base_ivfc_offset);
-    bool ReadPFS0Section(const NCASectionHeader& section, const NCASectionTableEntry& entry);
-
     u8 GetCryptoRevision() const;
-    std::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
-    std::optional<Core::Crypto::Key128> GetTitlekey();
-    VirtualFile Decrypt(const NCASectionHeader& header, VirtualFile in, u64 starting_offset);
+    boost::optional<Core::Crypto::Key128> GetKeyAreaKey(NCASectionCryptoType type) const;
+    boost::optional<Core::Crypto::Key128> GetTitlekey();
+    VirtualFile Decrypt(NCASectionHeader header, VirtualFile in, u64 starting_offset);
 
     std::vector<VirtualDir> dirs;
     std::vector<VirtualFile> files;
@@ -124,15 +118,15 @@ private:
     VirtualDir exefs = nullptr;
     VirtualFile file;
     VirtualFile bktr_base_romfs;
-    u64 ivfc_offset = 0;
+    u64 ivfc_offset;
 
     NCAHeader header{};
     bool has_rights_id{};
 
     Loader::ResultStatus status{};
 
-    bool encrypted = false;
-    bool is_update = false;
+    bool encrypted;
+    bool is_update;
 
     Core::Crypto::KeyManager keys;
 };

src/core/file_sys/control_metadata.cpp

@@ -8,32 +8,20 @@
 
 namespace FileSys {
 
-const std::array<const char*, 15> LANGUAGE_NAMES{{
-    "AmericanEnglish",
-    "BritishEnglish",
-    "Japanese",
-    "French",
-    "German",
-    "LatinAmericanSpanish",
-    "Spanish",
-    "Italian",
-    "Dutch",
-    "CanadianFrench",
-    "Portuguese",
-    "Russian",
-    "Korean",
-    "Taiwanese",
-    "Chinese",
-}};
+const std::array<const char*, 15> LANGUAGE_NAMES = {
+    "AmericanEnglish", "BritishEnglish", "Japanese",
+    "French",          "German",         "LatinAmericanSpanish",
+    "Spanish",         "Italian",        "Dutch",
+    "CanadianFrench",  "Portugese",      "Russian",
+    "Korean",          "Taiwanese",      "Chinese",
+};
 
 std::string LanguageEntry::GetApplicationName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(),
-                                                       application_name.size());
+    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(), 0x200);
 }
 
 std::string LanguageEntry::GetDeveloperName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(),
-                                                       developer_name.size());
+    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(), 0x100);
 }
 
 NACP::NACP(VirtualFile file) : raw(std::make_unique<RawNACP>()) {
@@ -68,18 +56,7 @@ u64 NACP::GetTitleId() const {
     return raw->title_id;
 }
 
-u64 NACP::GetDLCBaseTitleId() const {
-    return raw->dlc_base_title_id;
-}
-
 std::string NACP::GetVersionString() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(),
-                                                       raw->version_string.size());
-}
-
-std::vector<u8> NACP::GetRawBytes() const {
-    std::vector<u8> out(sizeof(RawNACP));
-    std::memcpy(out.data(), raw.get(), sizeof(RawNACP));
-    return out;
+    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(), 0x10);
 }
 } // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -79,9 +79,7 @@ public:
     std::string GetApplicationName(Language language = Language::Default) const;
     std::string GetDeveloperName(Language language = Language::Default) const;
     u64 GetTitleId() const;
-    u64 GetDLCBaseTitleId() const;
     std::string GetVersionString() const;
-    std::vector<u8> GetRawBytes() const;
 
 private:
     std::unique_ptr<RawNACP> raw;

src/core/file_sys/errors.h

@@ -8,10 +8,25 @@
 
 namespace FileSys {
 
-constexpr ResultCode ERROR_PATH_NOT_FOUND{ErrorModule::FS, 1};
-constexpr ResultCode ERROR_ENTITY_NOT_FOUND{ErrorModule::FS, 1002};
-constexpr ResultCode ERROR_SD_CARD_NOT_FOUND{ErrorModule::FS, 2001};
-constexpr ResultCode ERROR_INVALID_OFFSET{ErrorModule::FS, 6061};
-constexpr ResultCode ERROR_INVALID_SIZE{ErrorModule::FS, 6062};
+namespace ErrCodes {
+enum {
+    NotFound = 1,
+    TitleNotFound = 1002,
+    SdCardNotFound = 2001,
+    RomFSNotFound = 2520,
+};
+}
+
+constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
+
+// TODO(bunnei): Replace these with correct errors for Switch OS
+constexpr ResultCode ERROR_INVALID_PATH(-1);
+constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_FILE_NOT_FOUND(-1);
+constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(-1);
+constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(-1);
 
 } // namespace FileSys

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -23,10 +23,8 @@
  */
 
 #include <cstring>
-#include "common/alignment.h"
 #include "common/assert.h"
 #include "core/file_sys/fsmitm_romfsbuild.h"
-#include "core/file_sys/ips_layer.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_vector.h"
 
@@ -124,7 +122,7 @@ static u64 romfs_get_hash_table_count(u64 num_entries) {
     return count;
 }
 
-void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
+void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs,
                                        std::shared_ptr<RomFSBuildDirectoryContext> parent) {
     std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> child_dirs;
 
@@ -145,9 +143,6 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
             child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
             child->path = parent->path + "/" + kv.first;
 
-            if (ext != nullptr && ext->GetFileRelative(child->path + ".stub") != nullptr)
-                continue;
-
             // Sanity check on path_len
             ASSERT(child->path_len < FS_MAX_PATH);
 
@@ -161,24 +156,11 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
             child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
             child->path = parent->path + "/" + kv.first;
 
-            if (ext != nullptr && ext->GetFileRelative(child->path + ".stub") != nullptr)
-                continue;
-
             // Sanity check on path_len
             ASSERT(child->path_len < FS_MAX_PATH);
 
             child->source = root_romfs->GetFileRelative(child->path);
 
-            if (ext != nullptr) {
-                const auto ips = ext->GetFileRelative(child->path + ".ips");
-
-                if (ips != nullptr) {
-                    auto patched = PatchIPS(child->source, ips);
-                    if (patched != nullptr)
-                        child->source = std::move(patched);
-                }
-            }
-
             child->size = child->source->GetSize();
 
             AddFile(parent, child);
@@ -186,7 +168,7 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
     }
 
     for (auto& child : child_dirs) {
-        this->VisitDirectory(root_romfs, ext, child);
+        this->VisitDirectory(root_romfs, child);
     }
 }
 
@@ -200,7 +182,7 @@ bool RomFSBuildContext::AddDirectory(std::shared_ptr<RomFSBuildDirectoryContext>
     // Add a new directory.
     num_dirs++;
     dir_table_size +=
-        sizeof(RomFSDirectoryEntry) + Common::AlignUp(dir_ctx->path_len - dir_ctx->cur_path_ofs, 4);
+        sizeof(RomFSDirectoryEntry) + ((dir_ctx->path_len - dir_ctx->cur_path_ofs + 3) & ~3);
     dir_ctx->parent = parent_dir_ctx;
     directories.emplace(dir_ctx->path, dir_ctx);
 
@@ -218,22 +200,21 @@ bool RomFSBuildContext::AddFile(std::shared_ptr<RomFSBuildDirectoryContext> pare
     // Add a new file.
     num_files++;
     file_table_size +=
-        sizeof(RomFSFileEntry) + Common::AlignUp(file_ctx->path_len - file_ctx->cur_path_ofs, 4);
+        sizeof(RomFSFileEntry) + ((file_ctx->path_len - file_ctx->cur_path_ofs + 3) & ~3);
     file_ctx->parent = parent_dir_ctx;
     files.emplace(file_ctx->path, file_ctx);
 
     return true;
 }
 
-RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
-    : base(std::move(base_)), ext(std::move(ext_)) {
+RomFSBuildContext::RomFSBuildContext(VirtualDir base_) : base(std::move(base_)) {
     root = std::make_shared<RomFSBuildDirectoryContext>();
     root->path = "\0";
     directories.emplace(root->path, root);
     num_dirs = 1;
     dir_table_size = 0x18;
 
-    VisitDirectory(base, ext, root);
+    VisitDirectory(base, root);
 }
 
 RomFSBuildContext::~RomFSBuildContext() = default;
@@ -260,12 +241,12 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
     std::shared_ptr<RomFSBuildFileContext> prev_file = nullptr;
     for (const auto& it : files) {
         cur_file = it.second;
-        file_partition_size = Common::AlignUp(file_partition_size, 16);
+        file_partition_size = (file_partition_size + 0xFULL) & ~0xFULL;
         cur_file->offset = file_partition_size;
         file_partition_size += cur_file->size;
         cur_file->entry_offset = entry_offset;
-        entry_offset += sizeof(RomFSFileEntry) +
-                        Common::AlignUp(cur_file->path_len - cur_file->cur_path_ofs, 4);
+        entry_offset +=
+            sizeof(RomFSFileEntry) + ((cur_file->path_len - cur_file->cur_path_ofs + 3) & ~3);
         prev_file = cur_file;
     }
     // Assign deferred parent/sibling ownership.
@@ -282,8 +263,8 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
     for (const auto& it : directories) {
         cur_dir = it.second;
         cur_dir->entry_offset = entry_offset;
-        entry_offset += sizeof(RomFSDirectoryEntry) +
-                        Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4);
+        entry_offset +=
+            sizeof(RomFSDirectoryEntry) + ((cur_dir->path_len - cur_dir->cur_path_ofs + 3) & ~3);
     }
     // Assign deferred parent/sibling ownership.
     for (auto it = directories.rbegin(); it->second != root; ++it) {
@@ -316,7 +297,7 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
         out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, cur_file->source);
         std::memcpy(file_table.data() + cur_file->entry_offset, &cur_entry, sizeof(RomFSFileEntry));
         std::memset(file_table.data() + cur_file->entry_offset + sizeof(RomFSFileEntry), 0,
-                    Common::AlignUp(cur_entry.name_size, 4));
+                    (cur_entry.name_size + 3) & ~3);
         std::memcpy(file_table.data() + cur_file->entry_offset + sizeof(RomFSFileEntry),
                     cur_file->path.data() + cur_file->cur_path_ofs, name_size);
     }
@@ -341,10 +322,12 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
 
         cur_entry.name_size = name_size;
 
+        std::memcpy(dir_table.data() + cur_dir->entry_offset, &cur_entry,
+                    sizeof(RomFSDirectoryEntry));
         std::memcpy(dir_table.data() + cur_dir->entry_offset, &cur_entry,
                     sizeof(RomFSDirectoryEntry));
         std::memset(dir_table.data() + cur_dir->entry_offset + sizeof(RomFSDirectoryEntry), 0,
-                    Common::AlignUp(cur_entry.name_size, 4));
+                    (cur_entry.name_size + 3) & ~3);
         std::memcpy(dir_table.data() + cur_dir->entry_offset + sizeof(RomFSDirectoryEntry),
                     cur_dir->path.data() + cur_dir->cur_path_ofs, name_size);
     }
@@ -356,14 +339,14 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
     header.dir_hash_table_size = dir_hash_table_size;
     header.dir_table_size = dir_table_size;
     header.file_partition_ofs = ROMFS_FILEPARTITION_OFS;
-    header.dir_hash_table_ofs = Common::AlignUp(header.file_partition_ofs + file_partition_size, 4);
+    header.dir_hash_table_ofs = (header.file_partition_ofs + file_partition_size + 3ULL) & ~3ULL;
     header.dir_table_ofs = header.dir_hash_table_ofs + header.dir_hash_table_size;
     header.file_hash_table_ofs = header.dir_table_ofs + header.dir_table_size;
     header.file_table_ofs = header.file_hash_table_ofs + header.file_hash_table_size;
 
     std::vector<u8> header_data(sizeof(RomFSHeader));
     std::memcpy(header_data.data(), &header, header_data.size());
-    out.emplace(0, std::make_shared<VectorVfsFile>(std::move(header_data)));
+    out.emplace(0, std::make_shared<VectorVfsFile>(header_data));
 
     std::vector<u8> metadata(file_hash_table_size + file_table_size + dir_hash_table_size +
                              dir_table_size);
@@ -376,7 +359,7 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
                 file_hash_table.size() * sizeof(u32));
     index += file_hash_table.size() * sizeof(u32);
     std::memcpy(metadata.data() + index, file_table.data(), file_table.size());
-    out.emplace(header.dir_hash_table_ofs, std::make_shared<VectorVfsFile>(std::move(metadata)));
+    out.emplace(header.dir_hash_table_ofs, std::make_shared<VectorVfsFile>(metadata));
 
     return out;
 }

src/core/file_sys/fsmitm_romfsbuild.h

@@ -27,6 +27,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <boost/detail/container_fwd.hpp>
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 
@@ -39,7 +40,7 @@ struct RomFSFileEntry;
 
 class RomFSBuildContext {
 public:
-    explicit RomFSBuildContext(VirtualDir base, VirtualDir ext = nullptr);
+    explicit RomFSBuildContext(VirtualDir base);
     ~RomFSBuildContext();
 
     // This finalizes the context.
@@ -47,7 +48,6 @@ public:
 
 private:
     VirtualDir base;
-    VirtualDir ext;
     std::shared_ptr<RomFSBuildDirectoryContext> root;
     std::map<std::string, std::shared_ptr<RomFSBuildDirectoryContext>, std::less<>> directories;
     std::map<std::string, std::shared_ptr<RomFSBuildFileContext>, std::less<>> files;
@@ -59,8 +59,7 @@ private:
     u64 file_hash_table_size = 0;
     u64 file_partition_size = 0;
 
-    void VisitDirectory(VirtualDir filesys, VirtualDir ext,
-                        std::shared_ptr<RomFSBuildDirectoryContext> parent);
+    void VisitDirectory(VirtualDir filesys, std::shared_ptr<RomFSBuildDirectoryContext> parent);
 
     bool AddDirectory(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx,
                       std::shared_ptr<RomFSBuildDirectoryContext> dir_ctx);

src/core/file_sys/ips_layer.cpp

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

src/core/file_sys/ips_layer.h

@@ -1,44 +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_types.h"
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-
-VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips);
-
-class IPSwitchCompiler {
-public:
-    explicit IPSwitchCompiler(VirtualFile patch_text);
-    ~IPSwitchCompiler();
-
-    std::array<u8, 0x20> GetBuildID() const;
-    bool IsValid() const;
-    VirtualFile Apply(const VirtualFile& in) const;
-
-private:
-    struct IPSwitchPatch;
-
-    void ParseFlag(const std::string& flag);
-    void Parse();
-
-    bool valid = false;
-
-    VirtualFile patch_text;
-    std::vector<IPSwitchPatch> patches;
-    std::array<u8, 0x20> nso_build_id{};
-    bool is_little_endian = false;
-    s64 offset_shift = 0;
-    bool print_values = false;
-    std::string last_comment = "";
-};
-
-} // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

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

src/core/file_sys/partition_filesystem.h

@@ -35,6 +35,9 @@ public:
     std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
     void PrintDebugInfo() const;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     struct Header {
         u32_le magic;
@@ -81,6 +84,7 @@ private:
     std::size_t content_offset = 0;
 
     std::vector<VirtualFile> pfs_files;
+    std::vector<VirtualDir> pfs_dirs;
 };
 
 } // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -2,42 +2,22 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <array>
 #include <cstddef>
-#include <cstring>
 
-#include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
-#include "core/file_sys/ips_layer.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_layered.h"
-#include "core/file_sys/vfs_vector.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
-#include "core/settings.h"
 
 namespace FileSys {
 
 constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
-constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
-
-constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
-    "main",    "main.npdm", "rtld",    "sdk",     "subsdk0", "subsdk1", "subsdk2",
-    "subsdk3", "subsdk4",   "subsdk5", "subsdk6", "subsdk7", "subsdk8", "subsdk9",
-};
-
-struct NSOBuildHeader {
-    u32_le magic;
-    INSERT_PADDING_BYTES(0x3C);
-    std::array<u8, 0x20> build_id;
-    INSERT_PADDING_BYTES(0xA0);
-};
-static_assert(sizeof(NSOBuildHeader) == 0x100, "NSOBuildHeader has incorrect size.");
 
 std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     std::array<u8, sizeof(u32)> bytes{};
@@ -52,6 +32,15 @@ std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
+constexpr std::array<const char*, 2> PATCH_TYPE_NAMES{
+    "Update",
+    "LayeredFS",
+};
+
+std::string FormatPatchTypeName(PatchType type) {
+    return PATCH_TYPE_NAMES.at(static_cast<std::size_t>(type));
+}
+
 PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
@@ -62,164 +51,26 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     if (exefs == nullptr)
         return exefs;
 
-    if (Settings::values.dump_exefs) {
-        LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
-        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
-        if (dump_dir != nullptr) {
-            const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
-            VfsRawCopyD(exefs, exefs_dir);
-        }
-    }
-
     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 && update->GetExeFS() != nullptr &&
-        update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
-        exefs = update->GetExeFS();
-    }
-
-    // LayeredExeFS
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if (load_dir != nullptr && load_dir->GetSize() > 0) {
-        auto patch_dirs = load_dir->GetSubdirectories();
-        std::sort(
-            patch_dirs.begin(), patch_dirs.end(),
-            [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
-
-        std::vector<VirtualDir> layers;
-        layers.reserve(patch_dirs.size() + 1);
-        for (const auto& subdir : patch_dirs) {
-            auto exefs_dir = subdir->GetSubdirectory("exefs");
-            if (exefs_dir != nullptr)
-                layers.push_back(std::move(exefs_dir));
-        }
-        layers.push_back(exefs);
-
-        auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
-        if (layered != nullptr) {
-            LOG_INFO(Loader, "    ExeFS: LayeredExeFS patches applied successfully");
-            exefs = std::move(layered);
+    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;
 }
 
-static std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                               const std::string& build_id) {
-    std::vector<VirtualFile> out;
-    out.reserve(patch_dirs.size());
-    for (const auto& subdir : patch_dirs) {
-        auto exefs_dir = subdir->GetSubdirectory("exefs");
-        if (exefs_dir != nullptr) {
-            for (const auto& file : exefs_dir->GetFiles()) {
-                if (file->GetExtension() == "ips") {
-                    auto name = file->GetName();
-                    const auto p1 = name.substr(0, name.find('.'));
-                    const auto this_build_id = p1.substr(0, p1.find_last_not_of('0') + 1);
-
-                    if (build_id == this_build_id)
-                        out.push_back(file);
-                } else if (file->GetExtension() == "pchtxt") {
-                    IPSwitchCompiler compiler{file};
-                    if (!compiler.IsValid())
-                        continue;
-
-                    auto this_build_id = Common::HexArrayToString(compiler.GetBuildID());
-                    this_build_id =
-                        this_build_id.substr(0, this_build_id.find_last_not_of('0') + 1);
-
-                    if (build_id == this_build_id)
-                        out.push_back(file);
-                }
-            }
-        }
-    }
-
-    return out;
-}
-
-std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
-    if (nso.size() < 0x100)
-        return nso;
-
-    NSOBuildHeader header;
-    std::memcpy(&header, nso.data(), sizeof(NSOBuildHeader));
-
-    if (header.magic != Common::MakeMagic('N', 'S', 'O', '0'))
-        return nso;
-
-    const auto build_id_raw = Common::HexArrayToString(header.build_id);
-    const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
-
-    if (Settings::values.dump_nso) {
-        LOG_INFO(Loader, "Dumping NSO for build_id={}, title_id={:016X}", build_id, title_id);
-        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
-        if (dump_dir != nullptr) {
-            const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
-            const auto file = nso_dir->CreateFile(fmt::format("{}.nso", build_id));
-
-            file->Resize(nso.size());
-            file->WriteBytes(nso);
-        }
-    }
-
-    LOG_INFO(Loader, "Patching NSO for build_id={}", build_id);
-
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    auto patch_dirs = load_dir->GetSubdirectories();
-    std::sort(patch_dirs.begin(), patch_dirs.end(),
-              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
-    const auto patches = CollectPatches(patch_dirs, build_id);
-
-    auto out = nso;
-    for (const auto& patch_file : patches) {
-        if (patch_file->GetExtension() == "ips") {
-            LOG_INFO(Loader, "    - Applying IPS patch from mod \"{}\"",
-                     patch_file->GetContainingDirectory()->GetParentDirectory()->GetName());
-            const auto patched = PatchIPS(std::make_shared<VectorVfsFile>(out), patch_file);
-            if (patched != nullptr)
-                out = patched->ReadAllBytes();
-        } else if (patch_file->GetExtension() == "pchtxt") {
-            LOG_INFO(Loader, "    - Applying IPSwitch patch from mod \"{}\"",
-                     patch_file->GetContainingDirectory()->GetParentDirectory()->GetName());
-            const IPSwitchCompiler compiler{patch_file};
-            const auto patched = compiler.Apply(std::make_shared<VectorVfsFile>(out));
-            if (patched != nullptr)
-                out = patched->ReadAllBytes();
-        }
-    }
-
-    if (out.size() < 0x100)
-        return nso;
-    std::memcpy(out.data(), &header, sizeof(NSOBuildHeader));
-    return out;
-}
-
-bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
-    const auto build_id_raw = Common::HexArrayToString(build_id_);
-    const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
-
-    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
-
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    auto patch_dirs = load_dir->GetSubdirectories();
-    std::sort(patch_dirs.begin(), patch_dirs.end(),
-              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
-
-    return !CollectPatches(patch_dirs, build_id).empty();
-}
-
 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
     const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
-        load_dir == nullptr || load_dir->GetSize() <= 0) {
+    if (type != ContentRecordType::Program || load_dir == nullptr || load_dir->GetSize() <= 0) {
         return;
     }
 
@@ -233,17 +84,11 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
 
     std::vector<VirtualDir> layers;
-    std::vector<VirtualDir> layers_ext;
     layers.reserve(patch_dirs.size() + 1);
-    layers_ext.reserve(patch_dirs.size() + 1);
     for (const auto& subdir : patch_dirs) {
         auto romfs_dir = subdir->GetSubdirectory("romfs");
         if (romfs_dir != nullptr)
             layers.push_back(std::move(romfs_dir));
-
-        auto ext_dir = subdir->GetSubdirectory("romfs_ext");
-        if (ext_dir != nullptr)
-            layers_ext.push_back(std::move(ext_dir));
     }
     layers.push_back(std::move(extracted));
 
@@ -252,9 +97,7 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         return;
     }
 
-    auto layered_ext = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers_ext));
-
-    auto packed = CreateRomFS(std::move(layered), std::move(layered_ext));
+    auto packed = CreateRomFS(std::move(layered));
     if (packed == nullptr) {
         return;
     }
@@ -263,16 +106,10 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
     romfs = std::move(packed);
 }
 
-VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, ContentRecordType type,
-                                     VirtualFile update_raw) const {
-    const auto log_string = fmt::format("Patching RomFS for title_id={:016X}, type={:02X}",
-                                        title_id, static_cast<u8>(type))
-                                .c_str();
-
-    if (type == ContentRecordType::Program || type == ContentRecordType::Data)
-        LOG_INFO(Loader, log_string);
-    else
-        LOG_DEBUG(Loader, log_string);
+VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset,
+                                     ContentRecordType type) const {
+    LOG_INFO(Loader, "Patching RomFS for title_id={:016X}, type={:02X}", title_id,
+             static_cast<u8>(type));
 
     if (romfs == nullptr)
         return romfs;
@@ -287,14 +124,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
             LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed->GetEntryVersion(update_tid).value_or(0)));
-            romfs = new_nca->GetRomFS();
-        }
-    } else if (update_raw != nullptr) {
-        const auto new_nca = std::make_shared<NCA>(update_raw, romfs, ivfc_offset);
-        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
-            new_nca->GetRomFS() != nullptr) {
-            LOG_INFO(Loader, "    RomFS: Update (PACKED) applied successfully");
+                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
             romfs = new_nca->GetRomFS();
         }
     }
@@ -305,125 +135,52 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     return romfs;
 }
 
-static void AppendCommaIfNotEmpty(std::string& to, const std::string& with) {
-    if (to.empty())
-        to += with;
-    else
-        to += ", " + with;
-}
-
-static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
-    return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
-}
-
-std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
-    VirtualFile update_raw) const {
-    std::map<std::string, std::string, std::less<>> out;
+std::map<PatchType, std::string> PatchManager::GetPatchVersionNames() const {
+    std::map<PatchType, std::string> out;
     const auto installed = Service::FileSystem::GetUnionContents();
 
-    // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
     PatchManager update{update_tid};
     auto [nacp, discard_icon_file] = update.GetControlMetadata();
 
     if (nacp != nullptr) {
-        out.insert_or_assign("Update", nacp->GetVersionString());
+        out[PatchType::Update] = nacp->GetVersionString();
     } else {
         if (installed->HasEntry(update_tid, ContentRecordType::Program)) {
             const auto meta_ver = installed->GetEntryVersion(update_tid);
-            if (meta_ver.value_or(0) == 0) {
-                out.insert_or_assign("Update", "");
+            if (meta_ver == boost::none || meta_ver.get() == 0) {
+                out[PatchType::Update] = "";
             } else {
-                out.insert_or_assign(
-                    "Update", FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
+                out[PatchType::Update] =
+                    FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements);
             }
-        } else if (update_raw != nullptr) {
-            out.insert_or_assign("Update", "PACKED");
         }
     }
 
-    // General Mods (LayeredFS and IPS)
-    const auto mod_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
-        for (const auto& mod : mod_dir->GetSubdirectories()) {
-            std::string types;
-
-            const auto exefs_dir = mod->GetSubdirectory("exefs");
-            if (IsDirValidAndNonEmpty(exefs_dir)) {
-                bool ips = false;
-                bool ipswitch = false;
-                bool layeredfs = false;
-
-                for (const auto& file : exefs_dir->GetFiles()) {
-                    if (file->GetExtension() == "ips") {
-                        ips = true;
-                    } else if (file->GetExtension() == "pchtxt") {
-                        ipswitch = true;
-                    } else if (std::find(EXEFS_FILE_NAMES.begin(), EXEFS_FILE_NAMES.end(),
-                                         file->GetName()) != EXEFS_FILE_NAMES.end()) {
-                        layeredfs = true;
-                    }
-                }
-
-                if (ips)
-                    AppendCommaIfNotEmpty(types, "IPS");
-                if (ipswitch)
-                    AppendCommaIfNotEmpty(types, "IPSwitch");
-                if (layeredfs)
-                    AppendCommaIfNotEmpty(types, "LayeredExeFS");
-            }
-            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
-                AppendCommaIfNotEmpty(types, "LayeredFS");
-
-            if (types.empty())
-                continue;
-
-            out.insert_or_assign(mod->GetName(), types);
-        }
-    }
-
-    // DLC
-    const auto dlc_entries = installed->ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
-    std::vector<RegisteredCacheEntry> dlc_match;
-    dlc_match.reserve(dlc_entries.size());
-    std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
-                 [this, &installed](const RegisteredCacheEntry& entry) {
-                     return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
-                            installed->GetEntry(entry)->GetStatus() ==
-                                Loader::ResultStatus::Success;
-                 });
-    if (!dlc_match.empty()) {
-        // Ensure sorted so DLC IDs show in order.
-        std::sort(dlc_match.begin(), dlc_match.end());
-
-        std::string list;
-        for (size_t i = 0; i < dlc_match.size() - 1; ++i)
-            list += fmt::format("{}, ", dlc_match[i].title_id & 0x7FF);
-
-        list += fmt::format("{}", dlc_match.back().title_id & 0x7FF);
-
-        out.insert_or_assign("DLC", std::move(list));
-    }
+    const auto lfs_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    if (lfs_dir != nullptr && lfs_dir->GetSize() > 0)
+        out.insert_or_assign(PatchType::LayeredFS, "");
 
     return out;
 }
 
-std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
-    const auto installed{Service::FileSystem::GetUnionContents()};
+std::pair<std::shared_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
+    const auto& installed{Service::FileSystem::GetUnionContents()};
 
     const auto base_control_nca = installed->GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr)
         return {};
 
-    return ParseControlNCA(*base_control_nca);
+    return ParseControlNCA(base_control_nca);
 }
 
-std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(const NCA& nca) const {
-    const auto base_romfs = nca.GetRomFS();
+std::pair<std::shared_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(
+    const std::shared_ptr<NCA>& nca) const {
+    const auto base_romfs = nca->GetRomFS();
     if (base_romfs == nullptr)
         return {};
 
-    const auto romfs = PatchRomFS(base_romfs, nca.GetBaseIVFCOffset(), ContentRecordType::Control);
+    const auto romfs = PatchRomFS(base_romfs, nca->GetBaseIVFCOffset(), ContentRecordType::Control);
     if (romfs == nullptr)
         return {};
 
@@ -435,7 +192,7 @@ std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(cons
     if (nacp_file == nullptr)
         nacp_file = extracted->GetFile("Control.nacp");
 
-    auto nacp = nacp_file == nullptr ? nullptr : std::make_unique<NACP>(nacp_file);
+    const auto nacp = nacp_file == nullptr ? nullptr : std::make_shared<NACP>(nacp_file);
 
     VirtualFile icon_file;
     for (const auto& language : FileSys::LANGUAGE_NAMES) {
@@ -444,6 +201,6 @@ std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(cons
             break;
     }
 
-    return {std::move(nacp), icon_file};
+    return {nacp, icon_file};
 }
 } // namespace FileSys

src/core/file_sys/patch_manager.h

@@ -24,6 +24,13 @@ enum class TitleVersionFormat : u8 {
 std::string FormatTitleVersion(u32 version,
                                TitleVersionFormat format = TitleVersionFormat::ThreeElements);
 
+enum class PatchType {
+    Update,
+    LayeredFS,
+};
+
+std::string FormatPatchTypeName(PatchType type);
+
 // A centralized class to manage patches to games.
 class PatchManager {
 public:
@@ -34,33 +41,23 @@ public:
     // - Game Updates
     VirtualDir PatchExeFS(VirtualDir exefs) const;
 
-    // Currently tracked NSO patches:
-    // - IPS
-    // - IPSwitch
-    std::vector<u8> PatchNSO(const std::vector<u8>& nso) const;
-
-    // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
-    // Used to prevent expensive copies in NSO loader.
-    bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;
-
     // Currently tracked RomFS patches:
     // - Game Updates
     // - LayeredFS
     VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
-                           ContentRecordType type = ContentRecordType::Program,
-                           VirtualFile update_raw = nullptr) const;
+                           ContentRecordType type = ContentRecordType::Program) const;
 
     // Returns a vector of pairs between patch names and patch versions.
-    // i.e. Update 3.2.2 will return {"Update", "3.2.2"}
-    std::map<std::string, std::string, std::less<>> GetPatchVersionNames(
-        VirtualFile update_raw = nullptr) const;
+    // 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::unique_ptr<NACP>, VirtualFile> GetControlMetadata() const;
+    std::pair<std::shared_ptr<NACP>, VirtualFile> GetControlMetadata() const;
 
     // Version of GetControlMetadata that takes an arbitrary NCA
-    std::pair<std::unique_ptr<NACP>, VirtualFile> ParseControlNCA(const NCA& nca) const;
+    std::pair<std::shared_ptr<NACP>, VirtualFile> ParseControlNCA(
+        const std::shared_ptr<NCA>& nca) const;
 
 private:
     u64 title_id;