core/memory: Remove unused FlushMode enum

Recent changes to memory-related code resulted in this being unused, so
we can remove it.

.gitmodules

@@ -40,3 +40,9 @@
 [submodule "Vulkan-Headers"]
     path = externals/Vulkan-Headers
     url = https://github.com/KhronosGroup/Vulkan-Headers.git
+[submodule "externals/zstd"]
+    path = externals/zstd
+    url = https://github.com/facebook/zstd
+[submodule "sirit"]
+    path = externals/sirit
+    url = https://github.com/ReinUsesLisp/sirit

.travis/linux-mingw/build.sh

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

.travis/linux-mingw/deps.sh

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

.travis/linux-mingw/docker.sh

@@ -1,16 +1,6 @@
 #!/bin/bash -ex
 
 cd /yuzu
-MINGW_PACKAGES="sdl2-mingw-w64 qt5base-mingw-w64 qt5tools-mingw-w64 libsamplerate-mingw-w64 qt5multimedia-mingw-w64"
-apt-get update
-apt-get install -y gpg wget git python3-pip python ccache g++-mingw-w64-x86-64 gcc-mingw-w64-x86-64 mingw-w64-tools cmake
-echo 'deb http://ppa.launchpad.net/tobydox/mingw-w64/ubuntu bionic main ' > /etc/apt/sources.list.d/extras.list
-apt-key adv --keyserver keyserver.ubuntu.com --recv '72931B477E22FEFD47F8DECE02FE5F12ADDE29B2'
-apt-get update
-apt-get install -y ${MINGW_PACKAGES}
-
-# fix a problem in current MinGW headers
-wget -q https://raw.githubusercontent.com/Alexpux/mingw-w64/d0d7f784833bbb0b2d279310ddc6afb52fe47a46/mingw-w64-headers/crt/errno.h -O /usr/x86_64-w64-mingw32/include/errno.h
 # override Travis CI unreasonable ccache size
 echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"
 

.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 -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh

.travis/linux/deps.sh

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

.travis/linux/docker.sh

@@ -1,8 +1,5 @@
 #!/bin/bash -ex
 
-apt-get update
-apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev qtwebengine5-dev wget cmake ninja-build ccache
-
 cd /yuzu
 
 mkdir build && cd build

.travis/macos/upload.sh

@@ -19,18 +19,6 @@ $(brew --prefix)/opt/qt5/bin/macdeployqt "${REV_NAME}/yuzu.app" -executable="${R
 # move libs into folder for deployment
 macpack "${REV_NAME}/yuzu-cmd" -d "libs"
 
-# Make the yuzu.app application launch a debugging terminal.
-# Store away the actual binary
-mv ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu-bin
-
-cat > ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu <<EOL
-#!/usr/bin/env bash
-cd "\`dirname "\$0"\`"
-chmod +x yuzu-bin
-open yuzu-bin --args "\$@"
-EOL
-# Content that will serve as the launching script for yuzu (within the .app folder)
-
 # Make the launching script executable
 chmod +x ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu
 

CMakeLists.txt

@@ -309,7 +309,7 @@ if (CLANG_FORMAT)
     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 "Get-ChildItem '${SRCS}/*' -Include *.cpp,*.h -Recurse | Foreach {&'${CLANG_FORMAT}' -i $_.fullname}"
             COMMENT ${CCOMMENT})
     elseif(MINGW)
         add_custom_target(clang-format

CMakeModules/GenerateSCMRev.cmake

@@ -19,7 +19,7 @@ set(BUILD_VERSION "0")
 if (BUILD_REPOSITORY)
   # regex capture the string nightly or canary into CMAKE_MATCH_1
   string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
-  if (${CMAKE_MATCH_COUNT} GREATER 0)
+  if ("${CMAKE_MATCH_COUNT}" GREATER 0)
     # capitalize the first letter of each word in the repo name.
     string(REPLACE "-" ";" REPO_NAME_LIST ${CMAKE_MATCH_1})
     foreach(WORD ${REPO_NAME_LIST})

externals/CMakeLists.txt

@@ -49,6 +49,10 @@ add_subdirectory(open_source_archives EXCLUDE_FROM_ALL)
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 
+# Zstandard
+add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
+target_include_directories(libzstd_static INTERFACE ./zstd/lib)
+
 # SoundTouch
 add_subdirectory(soundtouch)
 
@@ -68,6 +72,11 @@ if (USE_DISCORD_PRESENCE)
     target_include_directories(discord-rpc INTERFACE ./discord-rpc/include)
 endif()
 
+# Sirit
+if (ENABLE_VULKAN)
+    add_subdirectory(sirit)
+endif()
+
 if (ENABLE_WEB_SERVICE)
     # LibreSSL
     set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")

src/CMakeLists.txt

@@ -18,6 +18,9 @@ if (MSVC)
     # 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)
 
+    # Ensure that projects build with Unicode support.
+    add_definitions(-DUNICODE -D_UNICODE)
+
     # /W3 - Level 3 warnings
     # /MP - Multi-threaded compilation
     # /Zi - Output debugging information

src/common/CMakeLists.txt

@@ -125,6 +125,8 @@ add_library(common STATIC
     uint128.h
     vector_math.h
     web_result.h
+    zstd_compression.cpp
+    zstd_compression.h
 )
 
 if(ARCHITECTURE_x86_64)
@@ -138,4 +140,4 @@ endif()
 create_target_directory_groups(common)
 
 target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
-target_link_libraries(common PRIVATE lz4_static)
+target_link_libraries(common PRIVATE lz4_static libzstd_static)

src/common/assert.h

@@ -57,3 +57,21 @@ __declspec(noinline, noreturn)
 
 #define UNIMPLEMENTED_IF(cond) ASSERT_MSG(!(cond), "Unimplemented code!")
 #define UNIMPLEMENTED_IF_MSG(cond, ...) ASSERT_MSG(!(cond), __VA_ARGS__)
+
+// If the assert is ignored, execute _b_
+#define ASSERT_OR_EXECUTE(_a_, _b_)                                                                \
+    do {                                                                                           \
+        ASSERT(_a_);                                                                               \
+        if (!(_a_)) {                                                                              \
+            _b_                                                                                    \
+        }                                                                                          \
+    } while (0)
+
+// If the assert is ignored, execute _b_
+#define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
+    do {                                                                                           \
+        ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
+        if (!(_a_)) {                                                                              \
+            _b_                                                                                    \
+        }                                                                                          \
+    } while (0)

src/common/lz4_compression.h

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#pragma once
+
 #include <vector>
 
 #include "common/common_types.h"

src/common/scope_exit.h

@@ -20,7 +20,7 @@ struct ScopeExitHelper {
 
 template <typename Func>
 ScopeExitHelper<Func> ScopeExit(Func&& func) {
-    return ScopeExitHelper<Func>(std::move(func));
+    return ScopeExitHelper<Func>(std::forward<Func>(func));
 }
 } // namespace detail
 

src/common/swap.h

@@ -21,11 +21,6 @@
 
 #if defined(_MSC_VER)
 #include <cstdlib>
-#elif defined(__linux__)
-#include <byteswap.h>
-#elif defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) ||                     \
-    defined(__NetBSD__) || defined(__OpenBSD__)
-#include <sys/endian.h>
 #endif
 #include <cstring>
 #include "common/common_types.h"
@@ -62,86 +57,49 @@
 namespace Common {
 
 #ifdef _MSC_VER
-inline u16 swap16(u16 _data) {
-    return _byteswap_ushort(_data);
+[[nodiscard]] inline u16 swap16(u16 data) noexcept {
+    return _byteswap_ushort(data);
 }
-inline u32 swap32(u32 _data) {
-    return _byteswap_ulong(_data);
+[[nodiscard]] inline u32 swap32(u32 data) noexcept {
+    return _byteswap_ulong(data);
 }
-inline u64 swap64(u64 _data) {
-    return _byteswap_uint64(_data);
+[[nodiscard]] inline u64 swap64(u64 data) noexcept {
+    return _byteswap_uint64(data);
 }
-#elif defined(ARCHITECTURE_ARM) && (__ARM_ARCH >= 6)
-inline u16 swap16(u16 _data) {
-    u32 data = _data;
-    __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));
-    return (u16)data;
-}
-inline u32 swap32(u32 _data) {
-    __asm__("rev %0, %1\n" : "=l"(_data) : "l"(_data));
-    return _data;
-}
-inline u64 swap64(u64 _data) {
-    return ((u64)swap32(_data) << 32) | swap32(_data >> 32);
-}
-#elif __linux__
-inline u16 swap16(u16 _data) {
-    return bswap_16(_data);
-}
-inline u32 swap32(u32 _data) {
-    return bswap_32(_data);
-}
-inline u64 swap64(u64 _data) {
-    return bswap_64(_data);
-}
-#elif __APPLE__
-inline __attribute__((always_inline)) u16 swap16(u16 _data) {
-    return (_data >> 8) | (_data << 8);
-}
-inline __attribute__((always_inline)) u32 swap32(u32 _data) {
-    return __builtin_bswap32(_data);
-}
-inline __attribute__((always_inline)) u64 swap64(u64 _data) {
-    return __builtin_bswap64(_data);
-}
-#elif defined(__Bitrig__) || defined(__OpenBSD__)
+#elif defined(__clang__) || defined(__GNUC__)
+#if defined(__Bitrig__) || defined(__OpenBSD__)
 // redefine swap16, swap32, swap64 as inline functions
 #undef swap16
 #undef swap32
 #undef swap64
-inline u16 swap16(u16 _data) {
-    return __swap16(_data);
+#endif
+[[nodiscard]] inline u16 swap16(u16 data) noexcept {
+    return __builtin_bswap16(data);
 }
-inline u32 swap32(u32 _data) {
-    return __swap32(_data);
+[[nodiscard]] inline u32 swap32(u32 data) noexcept {
+    return __builtin_bswap32(data);
 }
-inline u64 swap64(u64 _data) {
-    return __swap64(_data);
-}
-#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
-inline u16 swap16(u16 _data) {
-    return bswap16(_data);
-}
-inline u32 swap32(u32 _data) {
-    return bswap32(_data);
-}
-inline u64 swap64(u64 _data) {
-    return bswap64(_data);
+[[nodiscard]] inline u64 swap64(u64 data) noexcept {
+    return __builtin_bswap64(data);
 }
 #else
-// Slow generic implementation.
-inline u16 swap16(u16 data) {
+// Generic implementation.
+[[nodiscard]] inline u16 swap16(u16 data) noexcept {
     return (data >> 8) | (data << 8);
 }
-inline u32 swap32(u32 data) {
-    return (swap16(data) << 16) | swap16(data >> 16);
+[[nodiscard]] inline u32 swap32(u32 data) noexcept {
+    return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) |
+           ((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24);
 }
-inline u64 swap64(u64 data) {
-    return ((u64)swap32(data) << 32) | swap32(data >> 32);
+[[nodiscard]] inline u64 swap64(u64 data) noexcept {
+    return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) |
+           ((data & 0x0000FF0000000000ULL) >> 24) | ((data & 0x000000FF00000000ULL) >> 8) |
+           ((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
+           ((data & 0x000000000000FF00ULL) << 40) | ((data & 0x00000000000000FFULL) << 56);
 }
 #endif
 
-inline float swapf(float f) {
+[[nodiscard]] inline float swapf(float f) noexcept {
     static_assert(sizeof(u32) == sizeof(float), "float must be the same size as uint32_t.");
 
     u32 value;
@@ -153,7 +111,7 @@ inline float swapf(float f) {
     return f;
 }
 
-inline double swapd(double f) {
+[[nodiscard]] inline double swapd(double f) noexcept {
     static_assert(sizeof(u64) == sizeof(double), "double must be the same size as uint64_t.");
 
     u64 value;

src/common/zstd_compression.cpp

@@ -0,0 +1,53 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <algorithm>
+#include <zstd.h>
+
+#include "common/assert.h"
+#include "common/zstd_compression.h"
+
+namespace Common::Compression {
+
+std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32 compression_level) {
+    compression_level = std::clamp(compression_level, 1, ZSTD_maxCLevel());
+
+    const std::size_t max_compressed_size = ZSTD_compressBound(source_size);
+    std::vector<u8> compressed(max_compressed_size);
+
+    const std::size_t compressed_size =
+        ZSTD_compress(compressed.data(), compressed.size(), source, source_size, compression_level);
+
+    if (ZSTD_isError(compressed_size)) {
+        // Compression failed
+        return {};
+    }
+
+    compressed.resize(compressed_size);
+
+    return compressed;
+}
+
+std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size) {
+    return CompressDataZSTD(source, source_size, ZSTD_CLEVEL_DEFAULT);
+}
+
+std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed) {
+    const std::size_t decompressed_size =
+        ZSTD_getDecompressedSize(compressed.data(), compressed.size());
+    std::vector<u8> decompressed(decompressed_size);
+
+    const std::size_t uncompressed_result_size = ZSTD_decompress(
+        decompressed.data(), decompressed.size(), compressed.data(), compressed.size());
+
+    if (decompressed_size != uncompressed_result_size || ZSTD_isError(uncompressed_result_size)) {
+        // Decompression failed
+        return {};
+    }
+    return decompressed;
+}
+
+} // namespace Common::Compression

src/common/zstd_compression.h

@@ -0,0 +1,44 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace Common::Compression {
+
+/**
+ * Compresses a source memory region with Zstandard and returns the compressed data in a vector.
+ *
+ * @param source the uncompressed source memory region.
+ * @param source_size the size in bytes of the uncompressed source memory region.
+ * @param compression_level the used compression level. Should be between 1 and 22.
+ *
+ * @return the compressed data.
+ */
+std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32 compression_level);
+
+/**
+ * Compresses a source memory region with Zstandard with the default compression level and returns
+ * the compressed data in a vector.
+ *
+ * @param source the uncompressed source memory region.
+ * @param source_size the size in bytes of the uncompressed source memory region.
+ *
+ * @return the compressed data.
+ */
+std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size);
+
+/**
+ * Decompresses a source memory region with Zstandard and returns the uncompressed data in a vector.
+ *
+ * @param compressed the compressed source memory region.
+ *
+ * @return the decompressed data.
+ */
+std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed);
+
+} // namespace Common::Compression

src/core/CMakeLists.txt

@@ -88,6 +88,10 @@ add_library(core STATIC
     file_sys/vfs_vector.h
     file_sys/xts_archive.cpp
     file_sys/xts_archive.h
+    frontend/applets/error.cpp
+    frontend/applets/error.h
+    frontend/applets/general_frontend.cpp
+    frontend/applets/general_frontend.h
     frontend/applets/profile_select.cpp
     frontend/applets/profile_select.h
     frontend/applets/software_keyboard.cpp
@@ -177,12 +181,14 @@ add_library(core STATIC
     hle/service/am/applet_oe.h
     hle/service/am/applets/applets.cpp
     hle/service/am/applets/applets.h
+    hle/service/am/applets/error.cpp
+    hle/service/am/applets/error.h
+    hle/service/am/applets/general_backend.cpp
+    hle/service/am/applets/general_backend.h
     hle/service/am/applets/profile_select.cpp
     hle/service/am/applets/profile_select.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/applets/web_browser.cpp
     hle/service/am/applets/web_browser.h
     hle/service/am/idle.cpp

src/core/arm/arm_interface.h

@@ -7,6 +7,10 @@
 #include <array>
 #include "common/common_types.h"
 
+namespace Common {
+struct PageTable;
+}
+
 namespace Kernel {
 enum class VMAPermission : u8;
 }
@@ -49,8 +53,14 @@ public:
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
 
-    /// Notify CPU emulation that page tables have changed
-    virtual void PageTableChanged() = 0;
+    /// Notifies CPU emulation that the current page table has changed.
+    ///
+    /// @param new_page_table                 The new page table.
+    /// @param new_address_space_size_in_bits The new usable size of the address space in bits.
+    ///                                       This can be either 32, 36, or 39 on official software.
+    ///
+    virtual void PageTableChanged(Common::PageTable& new_page_table,
+                                  std::size_t new_address_space_size_in_bits) = 0;
 
     /**
      * Set the Program Counter to an address

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -99,7 +99,7 @@ public:
     }
 
     void CallSVC(u32 swi) override {
-        Kernel::CallSVC(swi);
+        Kernel::CallSVC(parent.system, swi);
     }
 
     void AddTicks(u64 ticks) override {
@@ -112,14 +112,14 @@ public:
         // Always execute at least one tick.
         amortized_ticks = std::max<u64>(amortized_ticks, 1);
 
-        parent.core_timing.AddTicks(amortized_ticks);
+        parent.system.CoreTiming().AddTicks(amortized_ticks);
         num_interpreted_instructions = 0;
     }
     u64 GetTicksRemaining() override {
-        return std::max(parent.core_timing.GetDowncount(), 0);
+        return std::max(parent.system.CoreTiming().GetDowncount(), 0);
     }
     u64 GetCNTPCT() override {
-        return Timing::CpuCyclesToClockCycles(parent.core_timing.GetTicks());
+        return Timing::CpuCyclesToClockCycles(parent.system.CoreTiming().GetTicks());
     }
 
     ARM_Dynarmic& parent;
@@ -128,18 +128,16 @@ public:
     u64 tpidr_el0 = 0;
 };
 
-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();
-
+std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit(Common::PageTable& page_table,
+                                                          std::size_t address_space_bits) const {
     Dynarmic::A64::UserConfig config;
 
     // Callbacks
     config.callbacks = cb.get();
 
     // Memory
-    config.page_table = reinterpret_cast<void**>(page_table);
-    config.page_table_address_space_bits = current_process->VMManager().GetAddressSpaceWidth();
+    config.page_table = reinterpret_cast<void**>(page_table.pointers.data());
+    config.page_table_address_space_bits = address_space_bits;
     config.silently_mirror_page_table = false;
 
     // Multi-process state
@@ -163,7 +161,6 @@ MICROPROFILE_DEFINE(ARM_Jit_Dynarmic, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64)
 
 void ARM_Dynarmic::Run() {
     MICROPROFILE_SCOPE(ARM_Jit_Dynarmic);
-    ASSERT(Memory::GetCurrentPageTable() == current_page_table);
 
     jit->Run();
 }
@@ -172,16 +169,11 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
+ARM_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
                            std::size_t core_index)
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{core_timing},
-      core_index{core_index}, core_timing{core_timing},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {
-    ThreadContext ctx{};
-    inner_unicorn.SaveContext(ctx);
-    PageTableChanged();
-    LoadContext(ctx);
-}
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{system},
+      core_index{core_index}, system{system},
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
 
@@ -276,9 +268,9 @@ void ARM_Dynarmic::ClearExclusiveState() {
     jit->ClearExclusiveState();
 }
 
-void ARM_Dynarmic::PageTableChanged() {
-    jit = MakeJit();
-    current_page_table = Memory::GetCurrentPageTable();
+void ARM_Dynarmic::PageTableChanged(Common::PageTable& page_table,
+                                    std::size_t new_address_space_size_in_bits) {
+    jit = MakeJit(page_table, new_address_space_size_in_bits);
 }
 
 DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(std::size_t core_count) : monitor(core_count) {}

src/core/arm/dynarmic/arm_dynarmic.h

@@ -12,23 +12,15 @@
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
-namespace Common {
-struct PageTable;
-}
-
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Core {
 
 class ARM_Dynarmic_Callbacks;
 class DynarmicExclusiveMonitor;
+class System;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
-                 std::size_t core_index);
+    ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
     ~ARM_Dynarmic() override;
 
     void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
@@ -56,10 +48,12 @@ public:
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
-    void PageTableChanged() override;
+    void PageTableChanged(Common::PageTable& new_page_table,
+                          std::size_t new_address_space_size_in_bits) override;
 
 private:
-    std::unique_ptr<Dynarmic::A64::Jit> MakeJit() const;
+    std::unique_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable& page_table,
+                                                std::size_t address_space_bits) const;
 
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
@@ -67,10 +61,8 @@ private:
     ARM_Unicorn inner_unicorn;
 
     std::size_t core_index;
-    Timing::CoreTiming& core_timing;
+    System& system;
     DynarmicExclusiveMonitor& exclusive_monitor;
-
-    Common::PageTable* current_page_table = nullptr;
 };
 
 class DynarmicExclusiveMonitor final : public ExclusiveMonitor {

src/core/arm/unicorn/arm_unicorn.cpp

@@ -10,7 +10,6 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/svc.h"
-#include "core/memory.h"
 
 namespace Core {
 
@@ -49,20 +48,6 @@ static void CodeHook(uc_engine* uc, uint64_t address, uint32_t size, void* user_
     }
 }
 
-static void InterruptHook(uc_engine* uc, u32 intNo, void* user_data) {
-    u32 esr{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr));
-
-    auto ec = esr >> 26;
-    auto iss = esr & 0xFFFFFF;
-
-    switch (ec) {
-    case 0x15: // SVC
-        Kernel::CallSVC(iss);
-        break;
-    }
-}
-
 static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value,
                                void* user_data) {
     ARM_Interface::ThreadContext ctx{};
@@ -72,7 +57,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
     return {};
 }
 
-ARM_Unicorn::ARM_Unicorn(Timing::CoreTiming& core_timing) : core_timing{core_timing} {
+ARM_Unicorn::ARM_Unicorn(System& system) : system{system} {
     CHECKED(uc_open(UC_ARCH_ARM64, UC_MODE_ARM, &uc));
 
     auto fpv = 3 << 20;
@@ -177,7 +162,7 @@ void ARM_Unicorn::Run() {
     if (GDBStub::IsServerEnabled()) {
         ExecuteInstructions(std::max(4000000, 0));
     } else {
-        ExecuteInstructions(std::max(core_timing.GetDowncount(), 0));
+        ExecuteInstructions(std::max(system.CoreTiming().GetDowncount(), 0));
     }
 }
 
@@ -190,7 +175,7 @@ MICROPROFILE_DEFINE(ARM_Jit_Unicorn, "ARM JIT", "Unicorn", MP_RGB(255, 64, 64));
 void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
     MICROPROFILE_SCOPE(ARM_Jit_Unicorn);
     CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
-    core_timing.AddTicks(num_instructions);
+    system.CoreTiming().AddTicks(num_instructions);
     if (GDBStub::IsServerEnabled()) {
         if (last_bkpt_hit && last_bkpt.type == GDBStub::BreakpointType::Execute) {
             uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);
@@ -273,4 +258,20 @@ void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
     last_bkpt_hit = true;
 }
 
+void ARM_Unicorn::InterruptHook(uc_engine* uc, u32 int_no, void* user_data) {
+    u32 esr{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr));
+
+    const auto ec = esr >> 26;
+    const auto iss = esr & 0xFFFFFF;
+
+    auto* const arm_instance = static_cast<ARM_Unicorn*>(user_data);
+
+    switch (ec) {
+    case 0x15: // SVC
+        Kernel::CallSVC(arm_instance->system, iss);
+        break;
+    }
+}
+
 } // namespace Core

src/core/arm/unicorn/arm_unicorn.h

@@ -9,15 +9,13 @@
 #include "core/arm/arm_interface.h"
 #include "core/gdbstub/gdbstub.h"
 
-namespace Core::Timing {
-class CoreTiming;
-}
-
 namespace Core {
 
+class System;
+
 class ARM_Unicorn final : public ARM_Interface {
 public:
-    explicit ARM_Unicorn(Timing::CoreTiming& core_timing);
+    explicit ARM_Unicorn(System& system);
     ~ARM_Unicorn() override;
 
     void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
@@ -43,12 +41,14 @@ public:
     void Run() override;
     void Step() override;
     void ClearInstructionCache() override;
-    void PageTableChanged() override{};
+    void PageTableChanged(Common::PageTable&, std::size_t) override {}
     void RecordBreak(GDBStub::BreakpointAddress bkpt);
 
 private:
+    static void InterruptHook(uc_engine* uc, u32 int_no, void* user_data);
+
     uc_engine* uc{};
-    Timing::CoreTiming& core_timing;
+    System& system;
     GDBStub::BreakpointAddress last_bkpt{};
     bool last_bkpt_hit = false;
 };

src/core/core.cpp

@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <array>
-#include <map>
 #include <memory>
-#include <thread>
 #include <utility>
 
 #include "common/file_util.h"
@@ -17,15 +15,21 @@
 #include "core/core_timing.h"
 #include "core/cpu_core_manager.h"
 #include "core/file_sys/mode.h"
+#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
+#include "core/frontend/applets/error.h"
+#include "core/frontend/applets/general_frontend.h"
+#include "core/frontend/applets/profile_select.h"
+#include "core/frontend/applets/software_keyboard.h"
+#include "core/frontend/applets/web_browser.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
+#include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
@@ -37,8 +41,6 @@
 #include "frontend/applets/software_keyboard.h"
 #include "frontend/applets/web_browser.h"
 #include "video_core/debug_utils/debug_utils.h"
-#include "video_core/gpu_asynch.h"
-#include "video_core/gpu_synch.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -80,7 +82,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 struct System::Impl {
-    explicit Impl(System& system) : kernel{system} {}
+    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system} {}
 
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
@@ -98,6 +100,7 @@ struct System::Impl {
         LOG_DEBUG(HW_Memory, "initialized OK");
 
         core_timing.Initialize();
+        cpu_core_manager.Initialize();
         kernel.Initialize();
 
         const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
@@ -108,17 +111,11 @@ struct System::Impl {
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr)
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
+        if (content_provider == nullptr)
+            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
 
         /// Create default implementations of applets if one is not provided.
-        if (profile_selector == nullptr)
-            profile_selector = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
-        if (software_keyboard == nullptr)
-            software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
-        if (web_browser == nullptr)
-            web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
-
-        auto main_process = Kernel::Process::Create(system, "main");
-        kernel.MakeCurrentProcess(main_process.get());
+        applet_manager.SetDefaultAppletsIfMissing();
 
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
@@ -131,16 +128,10 @@ struct System::Impl {
             return ResultStatus::ErrorVideoCore;
         }
 
+        gpu_core = VideoCore::CreateGPU(system);
+
         is_powered_on = true;
 
-        if (Settings::values.use_asynchronous_gpu_emulation) {
-            gpu_core = std::make_unique<VideoCommon::GPUAsynch>(system, *renderer);
-        } else {
-            gpu_core = std::make_unique<VideoCommon::GPUSynch>(system, *renderer);
-        }
-
-        cpu_core_manager.Initialize(system);
-
         LOG_DEBUG(Core, "Initialized OK");
 
         // Reset counters and set time origin to current frame
@@ -176,7 +167,8 @@ struct System::Impl {
             return init_result;
         }
 
-        const Loader::ResultStatus load_result{app_loader->Load(*kernel.CurrentProcess())};
+        auto main_process = Kernel::Process::Create(system, "main");
+        const auto [load_result, load_parameters] = app_loader->Load(*main_process);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
             Shutdown();
@@ -184,6 +176,16 @@ struct System::Impl {
             return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
                                              static_cast<u32>(load_result));
         }
+        kernel.MakeCurrentProcess(main_process.get());
+
+        // Main process has been loaded and been made current.
+        // Begin GPU and CPU execution.
+        gpu_core->Start();
+        cpu_core_manager.StartThreads();
+
+        // All threads are started, begin main process execution, now that we're in the clear.
+        main_process->Run(load_parameters->main_thread_priority,
+                          load_parameters->main_thread_stack_size);
 
         status = ResultStatus::Success;
         return status;
@@ -221,9 +223,7 @@ struct System::Impl {
         app_loader.reset();
 
         // Clear all applets
-        profile_selector.reset();
-        software_keyboard.reset();
-        web_browser.reset();
+        applet_manager.ClearAll();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -249,6 +249,8 @@ struct System::Impl {
     Kernel::KernelCore kernel;
     /// RealVfsFilesystem instance
     FileSys::VirtualFilesystem virtual_filesystem;
+    /// ContentProviderUnion instance
+    std::unique_ptr<FileSys::ContentProviderUnion> content_provider;
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
     std::unique_ptr<VideoCore::RendererBase> renderer;
@@ -260,9 +262,7 @@ struct System::Impl {
     std::unique_ptr<FileSys::CheatEngine> cheat_engine;
 
     /// Frontend applets
-    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_selector;
-    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
-    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
+    Service::AM::Applets::AppletManager applet_manager;
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -472,32 +472,41 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
-void System::SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet) {
-    impl->profile_selector = std::move(applet);
+void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
+    impl->applet_manager.SetAppletFrontendSet(std::move(set));
 }
 
-const Frontend::ProfileSelectApplet& System::GetProfileSelector() const {
-    return *impl->profile_selector;
+void System::SetDefaultAppletFrontendSet() {
+    impl->applet_manager.SetDefaultAppletFrontendSet();
 }
 
-void System::SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet) {
-    impl->software_keyboard = std::move(applet);
+Service::AM::Applets::AppletManager& System::GetAppletManager() {
+    return impl->applet_manager;
 }
 
-const Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
-    return *impl->software_keyboard;
+const Service::AM::Applets::AppletManager& System::GetAppletManager() const {
+    return impl->applet_manager;
 }
 
-void System::SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet) {
-    impl->web_browser = std::move(applet);
+void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
+    impl->content_provider = std::move(provider);
 }
 
-Frontend::WebBrowserApplet& System::GetWebBrowser() {
-    return *impl->web_browser;
+FileSys::ContentProvider& System::GetContentProvider() {
+    return *impl->content_provider;
 }
 
-const Frontend::WebBrowserApplet& System::GetWebBrowser() const {
-    return *impl->web_browser;
+const FileSys::ContentProvider& System::GetContentProvider() const {
+    return *impl->content_provider;
+}
+
+void System::RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
+                                     FileSys::ContentProvider* provider) {
+    impl->content_provider->SetSlot(slot, provider);
+}
+
+void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
+    impl->content_provider->ClearSlot(slot);
 }
 
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {

src/core/core.h

@@ -14,13 +14,13 @@
 
 namespace Core::Frontend {
 class EmuWindow;
-class ProfileSelectApplet;
-class SoftwareKeyboardApplet;
-class WebBrowserApplet;
 } // namespace Core::Frontend
 
 namespace FileSys {
 class CheatList;
+class ContentProvider;
+class ContentProviderUnion;
+enum class ContentProviderUnionSlot;
 class VfsFilesystem;
 } // namespace FileSys
 
@@ -35,9 +35,18 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader
 
-namespace Service::SM {
+namespace Service {
+
+namespace AM::Applets {
+struct AppletFrontendSet;
+class AppletManager;
+} // namespace AM::Applets
+
+namespace SM {
 class ServiceManager;
-} // namespace Service::SM
+} // namespace SM
+
+} // namespace Service
 
 namespace Tegra {
 class DebugContext;
@@ -257,18 +266,24 @@ public:
     void RegisterCheatList(const std::vector<FileSys::CheatList>& list, const std::string& build_id,
                            VAddr code_region_start, VAddr code_region_end);
 
-    void SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet);
+    void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
 
-    const Frontend::ProfileSelectApplet& GetProfileSelector() const;
+    void SetDefaultAppletFrontendSet();
 
-    void SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet);
+    Service::AM::Applets::AppletManager& GetAppletManager();
 
-    const Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
+    const Service::AM::Applets::AppletManager& GetAppletManager() const;
 
-    void SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet);
+    void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
 
-    Frontend::WebBrowserApplet& GetWebBrowser();
-    const Frontend::WebBrowserApplet& GetWebBrowser() const;
+    FileSys::ContentProvider& GetContentProvider();
+
+    const FileSys::ContentProvider& GetContentProvider() const;
+
+    void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
+                                 FileSys::ContentProvider* provider);
+
+    void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
 
 private:
     System();

src/core/core_cpu.cpp

@@ -55,13 +55,13 @@ Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_ba
     : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-        arm_interface = std::make_unique<ARM_Dynarmic>(core_timing, exclusive_monitor, core_index);
+        arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
-        arm_interface = std::make_unique<ARM_Unicorn>();
+        arm_interface = std::make_unique<ARM_Unicorn>(system);
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
     } else {
-        arm_interface = std::make_unique<ARM_Unicorn>(core_timing);
+        arm_interface = std::make_unique<ARM_Unicorn>(system);
     }
 
     scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);

src/core/cpu_core_manager.cpp

@@ -19,17 +19,19 @@ void RunCpuCore(const System& system, Cpu& cpu_state) {
 }
 } // Anonymous namespace
 
-CpuCoreManager::CpuCoreManager() = default;
+CpuCoreManager::CpuCoreManager(System& system) : system{system} {}
 CpuCoreManager::~CpuCoreManager() = default;
 
-void CpuCoreManager::Initialize(System& system) {
+void CpuCoreManager::Initialize() {
     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>(system, *exclusive_monitor, *barrier, index);
     }
+}
 
+void CpuCoreManager::StartThreads() {
     // 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();

src/core/cpu_core_manager.h

@@ -18,7 +18,7 @@ class System;
 
 class CpuCoreManager {
 public:
-    CpuCoreManager();
+    explicit CpuCoreManager(System& system);
     CpuCoreManager(const CpuCoreManager&) = delete;
     CpuCoreManager(CpuCoreManager&&) = delete;
 
@@ -27,7 +27,8 @@ public:
     CpuCoreManager& operator=(const CpuCoreManager&) = delete;
     CpuCoreManager& operator=(CpuCoreManager&&) = delete;
 
-    void Initialize(System& system);
+    void Initialize();
+    void StartThreads();
     void Shutdown();
 
     Cpu& GetCore(std::size_t index);
@@ -54,6 +55,8 @@ private:
 
     /// Map of guest threads to CPU cores
     std::map<std::thread::id, Cpu*> thread_to_cpu;
+
+    System& system;
 };
 
 } // namespace Core

src/core/crypto/key_manager.cpp

@@ -22,6 +22,7 @@
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
 #include "core/crypto/partition_data_manager.h"
@@ -794,7 +795,7 @@ void KeyManager::DeriveBase() {
 
 void KeyManager::DeriveETicket(PartitionDataManager& data) {
     // ETicket keys
-    const auto es = Service::FileSystem::GetUnionContents().GetEntry(
+    const auto es = Core::System::GetInstance().GetContentProvider().GetEntry(
         0x0100000000000033, FileSys::ContentRecordType::Program);
 
     if (es == nullptr)

src/core/file_sys/patch_manager.cpp

@@ -10,6 +10,7 @@
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/ips_layer.h"
@@ -69,7 +70,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
         }
     }
 
-    const auto installed = Service::FileSystem::GetUnionContents();
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
@@ -155,7 +156,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
     return out;
 }
 
-std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
+std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::string& name) const {
     if (nso.size() < sizeof(Loader::NSOHeader)) {
         return nso;
     }
@@ -171,18 +172,19 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
     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);
+        LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, 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));
+            const auto file = nso_dir->CreateFile(fmt::format("{}-{}.nso", name, build_id));
 
             file->Resize(nso.size());
             file->WriteBytes(nso);
         }
     }
 
-    LOG_INFO(Loader, "Patching NSO for build_id={}", build_id);
+    LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
 
     const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
     auto patch_dirs = load_dir->GetSubdirectories();
@@ -345,7 +347,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     if (romfs == nullptr)
         return romfs;
 
-    const auto installed = Service::FileSystem::GetUnionContents();
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
@@ -392,7 +394,7 @@ static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
 std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
     VirtualFile update_raw) const {
     std::map<std::string, std::string, std::less<>> out;
-    const auto installed = Service::FileSystem::GetUnionContents();
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto& disabled = Settings::values.disabled_addons[title_id];
 
     // Game Updates
@@ -466,10 +468,10 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 
     // DLC
     const auto dlc_entries = installed.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
-    std::vector<RegisteredCacheEntry> dlc_match;
+    std::vector<ContentProviderEntry> 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) {
+                 [this, &installed](const ContentProviderEntry& entry) {
                      return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
                             installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
                  });
@@ -492,7 +494,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 }
 
 std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
-    const auto installed{Service::FileSystem::GetUnionContents()};
+    const auto& installed = Core::System::GetInstance().GetContentProvider();
 
     const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr)

src/core/file_sys/patch_manager.h

@@ -44,7 +44,7 @@ public:
     // Currently tracked NSO patches:
     // - IPS
     // - IPSwitch
-    std::vector<u8> PatchNSO(const std::vector<u8>& nso) const;
+    std::vector<u8> PatchNSO(const std::vector<u8>& nso, const std::string& name) const;
 
     // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
     // Used to prevent expensive copies in NSO loader.

src/core/file_sys/registered_cache.cpp

@@ -23,19 +23,19 @@ namespace FileSys {
 // The size of blocks to use when vfs raw copying into nand.
 constexpr size_t VFS_RC_LARGE_COPY_BLOCK = 0x400000;
 
-std::string RegisteredCacheEntry::DebugInfo() const {
+std::string ContentProviderEntry::DebugInfo() const {
     return fmt::format("title_id={:016X}, content_type={:02X}", title_id, static_cast<u8>(type));
 }
 
-bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
+bool operator<(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs) {
     return (lhs.title_id < rhs.title_id) || (lhs.title_id == rhs.title_id && lhs.type < rhs.type);
 }
 
-bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
+bool operator==(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs) {
     return std::tie(lhs.title_id, lhs.type) == std::tie(rhs.title_id, rhs.type);
 }
 
-bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
+bool operator!=(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs) {
     return !operator==(lhs, rhs);
 }
 
@@ -84,7 +84,7 @@ static std::string GetCNMTName(TitleType type, u64 title_id) {
     return fmt::format("{}_{:016x}.cnmt", TITLE_TYPE_NAMES[index], title_id);
 }
 
-static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
+ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     switch (type) {
     case NCAContentType::Program:
         // TODO(DarkLordZach): Differentiate between Program and Patch
@@ -104,6 +104,28 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     }
 }
 
+ContentProvider::~ContentProvider() = default;
+
+bool ContentProvider::HasEntry(ContentProviderEntry entry) const {
+    return HasEntry(entry.title_id, entry.type);
+}
+
+VirtualFile ContentProvider::GetEntryUnparsed(ContentProviderEntry entry) const {
+    return GetEntryUnparsed(entry.title_id, entry.type);
+}
+
+VirtualFile ContentProvider::GetEntryRaw(ContentProviderEntry entry) const {
+    return GetEntryRaw(entry.title_id, entry.type);
+}
+
+std::unique_ptr<NCA> ContentProvider::GetEntry(ContentProviderEntry entry) const {
+    return GetEntry(entry.title_id, entry.type);
+}
+
+std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
+    return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
+}
+
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                        std::string_view path) const {
     const auto file = dir->GetFileRelative(path);
@@ -161,8 +183,8 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
     return file;
 }
 
-static std::optional<NcaID> CheckMapForContentRecord(
-    const boost::container::flat_map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
+static std::optional<NcaID> CheckMapForContentRecord(const std::map<u64, CNMT>& map, u64 title_id,
+                                                     ContentRecordType type) {
     if (map.find(title_id) == map.end())
         return {};
 
@@ -268,7 +290,7 @@ void RegisteredCache::Refresh() {
     AccumulateYuzuMeta();
 }
 
-RegisteredCache::RegisteredCache(VirtualDir dir_, RegisteredCacheParsingFunction parsing_function)
+RegisteredCache::RegisteredCache(VirtualDir dir_, ContentProviderParsingFunction parsing_function)
     : dir(std::move(dir_)), parser(std::move(parsing_function)) {
     Refresh();
 }
@@ -279,19 +301,11 @@ bool RegisteredCache::HasEntry(u64 title_id, ContentRecordType type) const {
     return GetEntryRaw(title_id, type) != nullptr;
 }
 
-bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {
-    return GetEntryRaw(entry) != nullptr;
-}
-
 VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
     const auto id = GetNcaIDFromMetadata(title_id, type);
     return id ? GetFileAtID(*id) : nullptr;
 }
 
-VirtualFile RegisteredCache::GetEntryUnparsed(RegisteredCacheEntry entry) const {
-    return GetEntryUnparsed(entry.title_id, entry.type);
-}
-
 std::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
     const auto meta_iter = meta.find(title_id);
     if (meta_iter != meta.end())
@@ -309,10 +323,6 @@ VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) c
     return id ? parser(GetFileAtID(*id), *id) : nullptr;
 }
 
-VirtualFile RegisteredCache::GetEntryRaw(RegisteredCacheEntry entry) const {
-    return GetEntryRaw(entry.title_id, entry.type);
-}
-
 std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType type) const {
     const auto raw = GetEntryRaw(title_id, type);
     if (raw == nullptr)
@@ -320,10 +330,6 @@ std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType t
     return std::make_unique<NCA>(raw, nullptr, 0, keys);
 }
 
-std::unique_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {
-    return GetEntry(entry.title_id, entry.type);
-}
-
 template <typename T>
 void RegisteredCache::IterateAllMetadata(
     std::vector<T>& out, std::function<T(const CNMT&, const ContentRecord&)> proc,
@@ -348,25 +354,14 @@ void RegisteredCache::IterateAllMetadata(
     }
 }
 
-std::vector<RegisteredCacheEntry> RegisteredCache::ListEntries() const {
-    std::vector<RegisteredCacheEntry> out;
-    IterateAllMetadata<RegisteredCacheEntry>(
-        out,
-        [](const CNMT& c, const ContentRecord& r) {
-            return RegisteredCacheEntry{c.GetTitleID(), r.type};
-        },
-        [](const CNMT& c, const ContentRecord& r) { return true; });
-    return out;
-}
-
-std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
+std::vector<ContentProviderEntry> RegisteredCache::ListEntriesFilter(
     std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
     std::optional<u64> title_id) const {
-    std::vector<RegisteredCacheEntry> out;
-    IterateAllMetadata<RegisteredCacheEntry>(
+    std::vector<ContentProviderEntry> out;
+    IterateAllMetadata<ContentProviderEntry>(
         out,
         [](const CNMT& c, const ContentRecord& r) {
-            return RegisteredCacheEntry{c.GetTitleID(), r.type};
+            return ContentProviderEntry{c.GetTitleID(), r.type};
         },
         [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
             if (title_type && *title_type != c.GetType())
@@ -521,37 +516,56 @@ bool RegisteredCache::RawInstallYuzuMeta(const CNMT& cnmt) {
                         }) != yuzu_meta.end();
 }
 
-RegisteredCacheUnion::RegisteredCacheUnion(std::vector<RegisteredCache*> caches)
-    : caches(std::move(caches)) {}
+ContentProviderUnion::~ContentProviderUnion() = default;
 
-void RegisteredCacheUnion::Refresh() {
-    for (const auto& c : caches)
-        c->Refresh();
+void ContentProviderUnion::SetSlot(ContentProviderUnionSlot slot, ContentProvider* provider) {
+    providers[slot] = provider;
 }
 
-bool RegisteredCacheUnion::HasEntry(u64 title_id, ContentRecordType type) const {
-    return std::any_of(caches.begin(), caches.end(), [title_id, type](const auto& cache) {
-        return cache->HasEntry(title_id, type);
-    });
+void ContentProviderUnion::ClearSlot(ContentProviderUnionSlot slot) {
+    providers[slot] = nullptr;
 }
 
-bool RegisteredCacheUnion::HasEntry(RegisteredCacheEntry entry) const {
-    return HasEntry(entry.title_id, entry.type);
+void ContentProviderUnion::Refresh() {
+    for (auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
+
+        provider.second->Refresh();
+    }
 }
 
-std::optional<u32> RegisteredCacheUnion::GetEntryVersion(u64 title_id) const {
-    for (const auto& c : caches) {
-        const auto res = c->GetEntryVersion(title_id);
-        if (res)
+bool ContentProviderUnion::HasEntry(u64 title_id, ContentRecordType type) const {
+    for (const auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
+
+        if (provider.second->HasEntry(title_id, type))
+            return true;
+    }
+
+    return false;
+}
+
+std::optional<u32> ContentProviderUnion::GetEntryVersion(u64 title_id) const {
+    for (const auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
+
+        const auto res = provider.second->GetEntryVersion(title_id);
+        if (res != std::nullopt)
             return res;
     }
 
-    return {};
+    return std::nullopt;
 }
 
-VirtualFile RegisteredCacheUnion::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
-    for (const auto& c : caches) {
-        const auto res = c->GetEntryUnparsed(title_id, type);
+VirtualFile ContentProviderUnion::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
+    for (const auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
+
+        const auto res = provider.second->GetEntryUnparsed(title_id, type);
         if (res != nullptr)
             return res;
     }
@@ -559,13 +573,12 @@ VirtualFile RegisteredCacheUnion::GetEntryUnparsed(u64 title_id, ContentRecordTy
     return nullptr;
 }
 
-VirtualFile RegisteredCacheUnion::GetEntryUnparsed(RegisteredCacheEntry entry) const {
-    return GetEntryUnparsed(entry.title_id, entry.type);
-}
+VirtualFile ContentProviderUnion::GetEntryRaw(u64 title_id, ContentRecordType type) const {
+    for (const auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
 
-VirtualFile RegisteredCacheUnion::GetEntryRaw(u64 title_id, ContentRecordType type) const {
-    for (const auto& c : caches) {
-        const auto res = c->GetEntryRaw(title_id, type);
+        const auto res = provider.second->GetEntryRaw(title_id, type);
         if (res != nullptr)
             return res;
     }
@@ -573,30 +586,30 @@ VirtualFile RegisteredCacheUnion::GetEntryRaw(u64 title_id, ContentRecordType ty
     return nullptr;
 }
 
-VirtualFile RegisteredCacheUnion::GetEntryRaw(RegisteredCacheEntry entry) const {
-    return GetEntryRaw(entry.title_id, entry.type);
+std::unique_ptr<NCA> ContentProviderUnion::GetEntry(u64 title_id, ContentRecordType type) const {
+    for (const auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
+
+        auto res = provider.second->GetEntry(title_id, type);
+        if (res != nullptr)
+            return res;
+    }
+
+    return nullptr;
 }
 
-std::unique_ptr<NCA> RegisteredCacheUnion::GetEntry(u64 title_id, ContentRecordType type) const {
-    const auto raw = GetEntryRaw(title_id, type);
-    if (raw == nullptr)
-        return nullptr;
-    return std::make_unique<NCA>(raw);
-}
+std::vector<ContentProviderEntry> ContentProviderUnion::ListEntriesFilter(
+    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
+    std::optional<u64> title_id) const {
+    std::vector<ContentProviderEntry> out;
 
-std::unique_ptr<NCA> RegisteredCacheUnion::GetEntry(RegisteredCacheEntry entry) const {
-    return GetEntry(entry.title_id, entry.type);
-}
+    for (const auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
 
-std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
-    std::vector<RegisteredCacheEntry> out;
-    for (const auto& c : caches) {
-        c->IterateAllMetadata<RegisteredCacheEntry>(
-            out,
-            [](const CNMT& c, const ContentRecord& r) {
-                return RegisteredCacheEntry{c.GetTitleID(), r.type};
-            },
-            [](const CNMT& c, const ContentRecord& r) { return true; });
+        const auto vec = provider.second->ListEntriesFilter(title_type, record_type, title_id);
+        std::copy(vec.begin(), vec.end(), std::back_inserter(out));
     }
 
     std::sort(out.begin(), out.end());
@@ -604,25 +617,87 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
     return out;
 }
 
-std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
+std::vector<std::pair<ContentProviderUnionSlot, ContentProviderEntry>>
+ContentProviderUnion::ListEntriesFilterOrigin(std::optional<ContentProviderUnionSlot> origin,
+                                              std::optional<TitleType> title_type,
+                                              std::optional<ContentRecordType> record_type,
+                                              std::optional<u64> title_id) const {
+    std::vector<std::pair<ContentProviderUnionSlot, ContentProviderEntry>> out;
+
+    for (const auto& provider : providers) {
+        if (provider.second == nullptr)
+            continue;
+
+        if (origin.has_value() && *origin != provider.first)
+            continue;
+
+        const auto vec = provider.second->ListEntriesFilter(title_type, record_type, title_id);
+        std::transform(vec.begin(), vec.end(), std::back_inserter(out),
+                       [&provider](const ContentProviderEntry& entry) {
+                           return std::make_pair(provider.first, entry);
+                       });
+    }
+
+    std::sort(out.begin(), out.end());
+    out.erase(std::unique(out.begin(), out.end()), out.end());
+    return out;
+}
+
+ManualContentProvider::~ManualContentProvider() = default;
+
+void ManualContentProvider::AddEntry(TitleType title_type, ContentRecordType content_type,
+                                     u64 title_id, VirtualFile file) {
+    entries.insert_or_assign({title_type, content_type, title_id}, file);
+}
+
+void ManualContentProvider::ClearAllEntries() {
+    entries.clear();
+}
+
+void ManualContentProvider::Refresh() {}
+
+bool ManualContentProvider::HasEntry(u64 title_id, ContentRecordType type) const {
+    return GetEntryRaw(title_id, type) != nullptr;
+}
+
+std::optional<u32> ManualContentProvider::GetEntryVersion(u64 title_id) const {
+    return std::nullopt;
+}
+
+VirtualFile ManualContentProvider::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
+    return GetEntryRaw(title_id, type);
+}
+
+VirtualFile ManualContentProvider::GetEntryRaw(u64 title_id, ContentRecordType type) const {
+    const auto iter =
+        std::find_if(entries.begin(), entries.end(), [title_id, type](const auto& entry) {
+            const auto [title_type, content_type, e_title_id] = entry.first;
+            return content_type == type && e_title_id == title_id;
+        });
+    if (iter == entries.end())
+        return nullptr;
+    return iter->second;
+}
+
+std::unique_ptr<NCA> ManualContentProvider::GetEntry(u64 title_id, ContentRecordType type) const {
+    const auto res = GetEntryRaw(title_id, type);
+    if (res == nullptr)
+        return nullptr;
+    return std::make_unique<NCA>(res, nullptr, 0, keys);
+}
+
+std::vector<ContentProviderEntry> ManualContentProvider::ListEntriesFilter(
     std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
     std::optional<u64> title_id) const {
-    std::vector<RegisteredCacheEntry> out;
-    for (const auto& c : caches) {
-        c->IterateAllMetadata<RegisteredCacheEntry>(
-            out,
-            [](const CNMT& c, const ContentRecord& r) {
-                return RegisteredCacheEntry{c.GetTitleID(), r.type};
-            },
-            [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
-                if (title_type && *title_type != c.GetType())
-                    return false;
-                if (record_type && *record_type != r.type)
-                    return false;
-                if (title_id && *title_id != c.GetTitleID())
-                    return false;
-                return true;
-            });
+    std::vector<ContentProviderEntry> out;
+
+    for (const auto& entry : entries) {
+        const auto [e_title_type, e_content_type, e_title_id] = entry.first;
+        if ((title_type == std::nullopt || e_title_type == *title_type) &&
+            (record_type == std::nullopt || e_content_type == *record_type) &&
+            (title_id == std::nullopt || e_title_id == *title_id)) {
+            out.emplace_back(ContentProviderEntry{e_title_id, e_content_type});
+        }
     }
 
     std::sort(out.begin(), out.end());

src/core/file_sys/registered_cache.h

@@ -21,12 +21,13 @@ class NSP;
 class XCI;
 
 enum class ContentRecordType : u8;
+enum class NCAContentType : u8;
 enum class TitleType : u8;
 
 struct ContentRecord;
 
 using NcaID = std::array<u8, 0x10>;
-using RegisteredCacheParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
+using ContentProviderParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
 using VfsCopyFunction = std::function<bool(const VirtualFile&, const VirtualFile&, size_t)>;
 
 enum class InstallResult {
@@ -36,7 +37,7 @@ enum class InstallResult {
     ErrorMetaFailed,
 };
 
-struct RegisteredCacheEntry {
+struct ContentProviderEntry {
     u64 title_id;
     ContentRecordType type;
 
@@ -47,12 +48,46 @@ constexpr u64 GetUpdateTitleID(u64 base_title_id) {
     return base_title_id | 0x800;
 }
 
+ContentRecordType GetCRTypeFromNCAType(NCAContentType type);
+
 // boost flat_map requires operator< for O(log(n)) lookups.
-bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
+bool operator<(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs);
 
 // std unique requires operator== to identify duplicates.
-bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
-bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
+bool operator==(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs);
+bool operator!=(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs);
+
+class ContentProvider {
+public:
+    virtual ~ContentProvider();
+
+    virtual void Refresh() = 0;
+
+    virtual bool HasEntry(u64 title_id, ContentRecordType type) const = 0;
+    virtual bool HasEntry(ContentProviderEntry entry) const;
+
+    virtual std::optional<u32> GetEntryVersion(u64 title_id) const = 0;
+
+    virtual VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const = 0;
+    virtual VirtualFile GetEntryUnparsed(ContentProviderEntry entry) const;
+
+    virtual VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const = 0;
+    virtual VirtualFile GetEntryRaw(ContentProviderEntry entry) const;
+
+    virtual std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const = 0;
+    virtual std::unique_ptr<NCA> GetEntry(ContentProviderEntry entry) const;
+
+    virtual std::vector<ContentProviderEntry> ListEntries() const;
+
+    // If a parameter is not std::nullopt, it will be filtered for from all entries.
+    virtual std::vector<ContentProviderEntry> ListEntriesFilter(
+        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
+        std::optional<u64> title_id = {}) const = 0;
+
+protected:
+    // A single instance of KeyManager to be used by GetEntry()
+    Core::Crypto::KeyManager keys;
+};
 
 /*
  * A class that catalogues NCAs in the registered directory structure.
@@ -67,39 +102,32 @@ bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs
  * (This impl also supports substituting the nca dir for an nca file, as that's more convenient
  * when 4GB splitting can be ignored.)
  */
-class RegisteredCache {
-    friend class RegisteredCacheUnion;
-
+class RegisteredCache : public ContentProvider {
 public:
     // Parsing function defines the conversion from raw file to NCA. If there are other steps
     // besides creating the NCA from the file (e.g. NAX0 on SD Card), that should go in a custom
     // parsing function.
     explicit RegisteredCache(VirtualDir dir,
-                             RegisteredCacheParsingFunction parsing_function =
+                             ContentProviderParsingFunction parsing_function =
                                  [](const VirtualFile& file, const NcaID& id) { return file; });
-    ~RegisteredCache();
+    ~RegisteredCache() override;
 
-    void Refresh();
+    void Refresh() override;
 
-    bool HasEntry(u64 title_id, ContentRecordType type) const;
-    bool HasEntry(RegisteredCacheEntry entry) const;
+    bool HasEntry(u64 title_id, ContentRecordType type) const override;
 
-    std::optional<u32> GetEntryVersion(u64 title_id) const;
+    std::optional<u32> GetEntryVersion(u64 title_id) const override;
 
-    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
+    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const override;
 
-    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
+    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const override;
 
-    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
-    std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
+    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const override;
 
-    std::vector<RegisteredCacheEntry> ListEntries() const;
     // If a parameter is not std::nullopt, it will be filtered for from all entries.
-    std::vector<RegisteredCacheEntry> ListEntriesFilter(
+    std::vector<ContentProviderEntry> ListEntriesFilter(
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
-        std::optional<u64> title_id = {}) const;
+        std::optional<u64> title_id = {}) const override;
 
     // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
     // there is a meta NCA and all of them are accessible.
@@ -131,46 +159,70 @@ private:
     bool RawInstallYuzuMeta(const CNMT& cnmt);
 
     VirtualDir dir;
-    RegisteredCacheParsingFunction parser;
-    Core::Crypto::KeyManager keys;
+    ContentProviderParsingFunction parser;
 
     // maps tid -> NcaID of meta
-    boost::container::flat_map<u64, NcaID> meta_id;
+    std::map<u64, NcaID> meta_id;
     // maps tid -> meta
-    boost::container::flat_map<u64, CNMT> meta;
+    std::map<u64, CNMT> meta;
     // maps tid -> meta for CNMT in yuzu_meta
-    boost::container::flat_map<u64, CNMT> yuzu_meta;
+    std::map<u64, CNMT> yuzu_meta;
 };
 
-// Combines multiple RegisteredCaches (i.e. SysNAND, UserNAND, SDMC) into one interface.
-class RegisteredCacheUnion {
+enum class ContentProviderUnionSlot {
+    SysNAND,        ///< System NAND
+    UserNAND,       ///< User NAND
+    SDMC,           ///< SD Card
+    FrontendManual, ///< Frontend-defined game list or similar
+};
+
+// Combines multiple ContentProvider(s) (i.e. SysNAND, UserNAND, SDMC) into one interface.
+class ContentProviderUnion : public ContentProvider {
 public:
-    explicit RegisteredCacheUnion(std::vector<RegisteredCache*> caches);
+    ~ContentProviderUnion() override;
 
-    void Refresh();
+    void SetSlot(ContentProviderUnionSlot slot, ContentProvider* provider);
+    void ClearSlot(ContentProviderUnionSlot slot);
 
-    bool HasEntry(u64 title_id, ContentRecordType type) const;
-    bool HasEntry(RegisteredCacheEntry entry) const;
+    void Refresh() override;
+    bool HasEntry(u64 title_id, ContentRecordType type) const override;
+    std::optional<u32> GetEntryVersion(u64 title_id) const override;
+    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const override;
+    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const override;
+    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const override;
+    std::vector<ContentProviderEntry> ListEntriesFilter(
+        std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
+        std::optional<u64> title_id) const override;
 
-    std::optional<u32> GetEntryVersion(u64 title_id) const;
-
-    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
-
-    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
-
-    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
-    std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
-
-    std::vector<RegisteredCacheEntry> ListEntries() const;
-    // If a parameter is not std::nullopt, it will be filtered for from all entries.
-    std::vector<RegisteredCacheEntry> ListEntriesFilter(
+    std::vector<std::pair<ContentProviderUnionSlot, ContentProviderEntry>> ListEntriesFilterOrigin(
+        std::optional<ContentProviderUnionSlot> origin = {},
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
         std::optional<u64> title_id = {}) const;
 
 private:
-    std::vector<RegisteredCache*> caches;
+    std::map<ContentProviderUnionSlot, ContentProvider*> providers;
+};
+
+class ManualContentProvider : public ContentProvider {
+public:
+    ~ManualContentProvider() override;
+
+    void AddEntry(TitleType title_type, ContentRecordType content_type, u64 title_id,
+                  VirtualFile file);
+    void ClearAllEntries();
+
+    void Refresh() override;
+    bool HasEntry(u64 title_id, ContentRecordType type) const override;
+    std::optional<u32> GetEntryVersion(u64 title_id) const override;
+    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const override;
+    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const override;
+    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const override;
+    std::vector<ContentProviderEntry> ListEntriesFilter(
+        std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
+        std::optional<u64> title_id) const override;
+
+private:
+    std::map<std::tuple<TitleType, ContentRecordType, u64>, VirtualFile> entries;
 };
 
 } // namespace FileSys

src/core/file_sys/romfs_factory.cpp

@@ -48,7 +48,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, Conte
 
     switch (storage) {
     case StorageId::None:
-        res = Service::FileSystem::GetUnionContents().GetEntry(title_id, type);
+        res = Core::System::GetInstance().GetContentProvider().GetEntry(title_id, type);
         break;
     case StorageId::NandSystem:
         res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);

src/core/file_sys/submission_package.cpp

@@ -143,11 +143,12 @@ std::multimap<u64, std::shared_ptr<NCA>> NSP::GetNCAsByTitleID() const {
     return out;
 }
 
-std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> NSP::GetNCAs() const {
+std::map<u64, std::map<std::pair<TitleType, ContentRecordType>, std::shared_ptr<NCA>>>
+NSP::GetNCAs() const {
     return ncas;
 }
 
-std::shared_ptr<NCA> NSP::GetNCA(u64 title_id, ContentRecordType type) const {
+std::shared_ptr<NCA> NSP::GetNCA(u64 title_id, ContentRecordType type, TitleType title_type) const {
     if (extracted)
         LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
 
@@ -155,14 +156,14 @@ std::shared_ptr<NCA> NSP::GetNCA(u64 title_id, ContentRecordType type) const {
     if (title_id_iter == ncas.end())
         return nullptr;
 
-    const auto type_iter = title_id_iter->second.find(type);
+    const auto type_iter = title_id_iter->second.find({title_type, type});
     if (type_iter == title_id_iter->second.end())
         return nullptr;
 
     return type_iter->second;
 }
 
-VirtualFile NSP::GetNCAFile(u64 title_id, ContentRecordType type) const {
+VirtualFile NSP::GetNCAFile(u64 title_id, ContentRecordType type, TitleType title_type) const {
     if (extracted)
         LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
     const auto nca = GetNCA(title_id, type);
@@ -240,7 +241,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
             const CNMT cnmt(inner_file);
             auto& ncas_title = ncas[cnmt.GetTitleID()];
 
-            ncas_title[ContentRecordType::Meta] = nca;
+            ncas_title[{cnmt.GetType(), ContentRecordType::Meta}] = nca;
             for (const auto& rec : cnmt.GetContentRecords()) {
                 const auto id_string = Common::HexArrayToString(rec.nca_id, false);
                 const auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
@@ -258,7 +259,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                 if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
                     (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
                      (cnmt.GetTitleID() & 0x800) != 0)) {
-                    ncas_title[rec.type] = std::move(next_nca);
+                    ncas_title[{cnmt.GetType(), rec.type}] = std::move(next_nca);
                 }
             }
 

src/core/file_sys/submission_package.h

@@ -42,9 +42,12 @@ public:
     // Type 0 Only (Collection of NCAs + Certificate + Ticket + Meta XML)
     std::vector<std::shared_ptr<NCA>> GetNCAsCollapsed() const;
     std::multimap<u64, std::shared_ptr<NCA>> GetNCAsByTitleID() const;
-    std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> GetNCAs() const;
-    std::shared_ptr<NCA> GetNCA(u64 title_id, ContentRecordType type) const;
-    VirtualFile GetNCAFile(u64 title_id, ContentRecordType type) const;
+    std::map<u64, std::map<std::pair<TitleType, ContentRecordType>, std::shared_ptr<NCA>>> GetNCAs()
+        const;
+    std::shared_ptr<NCA> GetNCA(u64 title_id, ContentRecordType type,
+                                TitleType title_type = TitleType::Application) const;
+    VirtualFile GetNCAFile(u64 title_id, ContentRecordType type,
+                           TitleType title_type = TitleType::Application) const;
     std::vector<Core::Crypto::Key128> GetTitlekey() const;
 
     std::vector<VirtualFile> GetFiles() const override;
@@ -67,7 +70,7 @@ private:
 
     std::shared_ptr<PartitionFilesystem> pfs;
     // Map title id -> {map type -> NCA}
-    std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> ncas;
+    std::map<u64, std::map<std::pair<TitleType, ContentRecordType>, std::shared_ptr<NCA>>> ncas;
     std::vector<VirtualFile> ticket_files;
 
     Core::Crypto::KeyManager keys;

src/core/frontend/applets/error.cpp

@@ -0,0 +1,34 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/frontend/applets/error.h"
+
+namespace Core::Frontend {
+
+ErrorApplet::~ErrorApplet() = default;
+
+void DefaultErrorApplet::ShowError(ResultCode error, std::function<void()> finished) const {
+    LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
+                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
+}
+
+void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
+                                                std::function<void()> finished) const {
+    LOG_CRITICAL(
+        Service_Fatal,
+        "Application requested error display: {:04X}-{:04X} (raw={:08X}) with timestamp={:016X}",
+        static_cast<u32>(error.module.Value()), error.description.Value(), error.raw, time.count());
+}
+
+void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_text,
+                                             std::string detail_text,
+                                             std::function<void()> finished) const {
+    LOG_CRITICAL(Service_Fatal,
+                 "Application requested custom error with error_code={:04X}-{:04X} (raw={:08X})",
+                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
+    LOG_CRITICAL(Service_Fatal, "    Main Text: {}", main_text);
+    LOG_CRITICAL(Service_Fatal, "    Detail Text: {}", detail_text);
+}
+
+} // namespace Core::Frontend

src/core/frontend/applets/error.h

@@ -0,0 +1,37 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <chrono>
+#include <functional>
+
+#include "core/hle/result.h"
+
+namespace Core::Frontend {
+
+class ErrorApplet {
+public:
+    virtual ~ErrorApplet();
+
+    virtual void ShowError(ResultCode error, std::function<void()> finished) const = 0;
+
+    virtual void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
+                                        std::function<void()> finished) const = 0;
+
+    virtual void ShowCustomErrorText(ResultCode error, std::string dialog_text,
+                                     std::string fullscreen_text,
+                                     std::function<void()> finished) const = 0;
+};
+
+class DefaultErrorApplet final : public ErrorApplet {
+public:
+    void ShowError(ResultCode error, std::function<void()> finished) const override;
+    void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
+                                std::function<void()> finished) const override;
+    void ShowCustomErrorText(ResultCode error, std::string main_text, std::string detail_text,
+                             std::function<void()> finished) const override;
+};
+
+} // namespace Core::Frontend

src/core/frontend/applets/general_frontend.cpp

@@ -0,0 +1,27 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/frontend/applets/general_frontend.h"
+
+namespace Core::Frontend {
+
+PhotoViewerApplet::~PhotoViewerApplet() = default;
+
+DefaultPhotoViewerApplet::~DefaultPhotoViewerApplet() {}
+
+void DefaultPhotoViewerApplet::ShowPhotosForApplication(u64 title_id,
+                                                        std::function<void()> finished) const {
+    LOG_INFO(Service_AM,
+             "Application requested frontend to display stored photos for title_id={:016X}",
+             title_id);
+    finished();
+}
+
+void DefaultPhotoViewerApplet::ShowAllPhotos(std::function<void()> finished) const {
+    LOG_INFO(Service_AM, "Application requested frontend to display all stored photos.");
+    finished();
+}
+
+} // namespace Core::Frontend

src/core/frontend/applets/general_frontend.h

@@ -0,0 +1,28 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include "common/common_types.h"
+
+namespace Core::Frontend {
+
+class PhotoViewerApplet {
+public:
+    virtual ~PhotoViewerApplet();
+
+    virtual void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const = 0;
+    virtual void ShowAllPhotos(std::function<void()> finished) const = 0;
+};
+
+class DefaultPhotoViewerApplet final : public PhotoViewerApplet {
+public:
+    ~DefaultPhotoViewerApplet() override;
+
+    void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const override;
+    void ShowAllPhotos(std::function<void()> finished) const override;
+};
+
+} // namespace Core::Frontend

src/core/frontend/emu_window.h

@@ -12,6 +12,23 @@
 
 namespace Core::Frontend {
 
+/**
+ * Represents a graphics context that can be used for background computation or drawing. If the
+ * graphics backend doesn't require the context, then the implementation of these methods can be
+ * stubs
+ */
+class GraphicsContext {
+public:
+    /// Makes the graphics context current for the caller thread
+    virtual void MakeCurrent() = 0;
+
+    /// Releases (dunno if this is the "right" word) the context from the caller thread
+    virtual void DoneCurrent() = 0;
+
+    /// Swap buffers to display the next frame
+    virtual void SwapBuffers() = 0;
+};
+
 /**
  * Abstraction class used to provide an interface between emulation code and the frontend
  * (e.g. SDL, QGLWidget, GLFW, etc...).
@@ -30,7 +47,7 @@ namespace Core::Frontend {
  * - DO NOT TREAT THIS CLASS AS A GUI TOOLKIT ABSTRACTION LAYER. That's not what it is. Please
  *   re-read the upper points again and think about it if you don't see this.
  */
-class EmuWindow {
+class EmuWindow : public GraphicsContext {
 public:
     /// Data structure to store emuwindow configuration
     struct WindowConfig {
@@ -40,17 +57,21 @@ public:
         std::pair<unsigned, unsigned> min_client_area_size;
     };
 
-    /// Swap buffers to display the next frame
-    virtual void SwapBuffers() = 0;
-
     /// Polls window events
     virtual void PollEvents() = 0;
 
-    /// Makes the graphics context current for the caller thread
-    virtual void MakeCurrent() = 0;
-
-    /// Releases (dunno if this is the "right" word) the GLFW context from the caller thread
-    virtual void DoneCurrent() = 0;
+    /**
+     * Returns a GraphicsContext that the frontend provides that is shared with the emu window. This
+     * context can be used from other threads for background graphics computation. If the frontend
+     * is using a graphics backend that doesn't need anything specific to run on a different thread,
+     * then it can use a stubbed implemenation for GraphicsContext.
+     *
+     * If the return value is null, then the core should assume that the frontend cannot provide a
+     * Shared Context
+     */
+    virtual std::unique_ptr<GraphicsContext> CreateSharedContext() const {
+        return nullptr;
+    }
 
     /**
      * Signal that a touch pressed event has occurred (e.g. mouse click pressed)

src/core/hle/kernel/client_port.h

@@ -25,7 +25,7 @@ public:
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::ClientPort;
+    static constexpr HandleType HANDLE_TYPE = HandleType::ClientPort;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/client_session.h

@@ -29,7 +29,7 @@ public:
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::ClientSession;
+    static constexpr HandleType HANDLE_TYPE = HandleType::ClientSession;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/kernel.cpp

@@ -21,6 +21,7 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
+#include "core/memory.h"
 
 namespace Kernel {
 
@@ -45,8 +46,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
 
     bool resume = true;
 
-    if (thread->GetStatus() == ThreadStatus::WaitSynchAny ||
-        thread->GetStatus() == ThreadStatus::WaitSynchAll ||
+    if (thread->GetStatus() == ThreadStatus::WaitSynch ||
         thread->GetStatus() == ThreadStatus::WaitHLEEvent) {
         // Remove the thread from each of its waiting objects' waitlists
         for (const auto& object : thread->GetWaitObjects()) {
@@ -181,6 +181,12 @@ void KernelCore::AppendNewProcess(SharedPtr<Process> process) {
 
 void KernelCore::MakeCurrentProcess(Process* process) {
     impl->current_process = process;
+
+    if (process == nullptr) {
+        return;
+    }
+
+    Memory::SetCurrentPageTable(*process);
 }
 
 Process* KernelCore::CurrentProcess() {

src/core/hle/kernel/process.cpp

@@ -28,24 +28,20 @@ namespace {
  *
  * @param owner_process The parent process for the main thread
  * @param kernel The kernel instance to create the main thread under.
- * @param entry_point The address at which the thread should start execution
  * @param priority The priority to give the main thread
  */
-void SetupMainThread(Process& owner_process, KernelCore& kernel, VAddr entry_point, u32 priority) {
-    // Setup page table so we can write to memory
-    Memory::SetCurrentPageTable(&owner_process.VMManager().page_table);
-
-    // Initialize new "main" thread
-    const VAddr stack_top = owner_process.VMManager().GetTLSIORegionEndAddress();
+void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
+    const auto& vm_manager = owner_process.VMManager();
+    const VAddr entry_point = vm_manager.GetCodeRegionBaseAddress();
+    const VAddr stack_top = vm_manager.GetTLSIORegionEndAddress();
     auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0,
                                      owner_process.GetIdealCore(), stack_top, owner_process);
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
-    const Handle guest_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
-    thread->SetGuestHandle(guest_handle);
-    thread->GetContext().cpu_registers[1] = guest_handle;
+    const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
+    thread->GetContext().cpu_registers[1] = thread_handle;
 
     // Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
     thread->ResumeFromWait();
@@ -120,7 +116,7 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
     return handle_table.SetSize(capabilities.GetHandleTableSize());
 }
 
-void Process::Run(VAddr entry_point, s32 main_thread_priority, u64 stack_size) {
+void Process::Run(s32 main_thread_priority, u64 stack_size) {
     // The kernel always ensures that the given stack size is page aligned.
     main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);
 
@@ -136,7 +132,7 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u64 stack_size) {
     vm_manager.LogLayout();
     ChangeStatus(ProcessStatus::Running);
 
-    SetupMainThread(*this, kernel, entry_point, main_thread_priority);
+    SetupMainThread(*this, kernel, main_thread_priority);
 }
 
 void Process::PrepareForTermination() {
@@ -151,8 +147,7 @@ void Process::PrepareForTermination() {
                 continue;
 
             // TODO(Subv): When are the other running/ready threads terminated?
-            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynchAny ||
-                           thread->GetStatus() == ThreadStatus::WaitSynchAll,
+            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynch,
                        "Exiting processes with non-waiting threads is currently unimplemented");
 
             thread->Stop();
@@ -243,13 +238,11 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
     MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeData);
 
     code_memory_size += module_.memory.size();
-
-    // Clear instruction cache in CPU JIT
-    system.InvalidateCpuInstructionCaches();
 }
 
 Process::Process(Core::System& system)
-    : WaitObject{system.Kernel()}, address_arbiter{system}, mutex{system}, system{system} {}
+    : WaitObject{system.Kernel()}, vm_manager{system},
+      address_arbiter{system}, mutex{system}, system{system} {}
 
 Process::~Process() = default;
 

src/core/hle/kernel/process.h

@@ -85,7 +85,7 @@ public:
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::Process;
+    static constexpr HandleType HANDLE_TYPE = HandleType::Process;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
@@ -225,9 +225,12 @@ public:
     ResultCode LoadFromMetadata(const FileSys::ProgramMetadata& metadata);
 
     /**
-     * Applies address space changes and launches the process main thread.
+     * Starts the main application thread for this process.
+     *
+     * @param main_thread_priority The priority for the main thread.
+     * @param stack_size           The stack size for the main thread in bytes.
      */
-    void Run(VAddr entry_point, s32 main_thread_priority, u64 stack_size);
+    void Run(s32 main_thread_priority, u64 stack_size);
 
     /**
      * Prepares a process for termination by stopping all of its threads

src/core/hle/kernel/readable_event.h

@@ -31,7 +31,7 @@ public:
         return reset_type;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::ReadableEvent;
+    static constexpr HandleType HANDLE_TYPE = HandleType::ReadableEvent;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/resource_limit.h

@@ -41,7 +41,7 @@ public:
         return GetTypeName();
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::ResourceLimit;
+    static constexpr HandleType HANDLE_TYPE = HandleType::ResourceLimit;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/scheduler.cpp

@@ -101,7 +101,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         auto* const thread_owner_process = current_thread->GetOwnerProcess();
         if (previous_process != thread_owner_process) {
             system.Kernel().MakeCurrentProcess(thread_owner_process);
-            Memory::SetCurrentPageTable(&thread_owner_process->VMManager().page_table);
         }
 
         cpu_core.LoadContext(new_thread->GetContext());

src/core/hle/kernel/server_port.h

@@ -43,7 +43,7 @@ public:
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::ServerPort;
+    static constexpr HandleType HANDLE_TYPE = HandleType::ServerPort;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/server_session.cpp

@@ -28,11 +28,9 @@ ServerSession::~ServerSession() {
     // the emulated application.
 
     // Decrease the port's connection count.
-    if (parent->port)
+    if (parent->port) {
         parent->port->ConnectionClosed();
-
-    // TODO(Subv): Wake up all the ClientSession's waiting threads and set
-    // the SendSyncRequest result to 0xC920181A.
+    }
 
     parent->server = nullptr;
 }
@@ -74,9 +72,6 @@ void ServerSession::ClientDisconnected() {
         handler->ClientDisconnected(this);
     }
 
-    // TODO(Subv): Force a wake up of all the ServerSession's waiting threads and set
-    // their WaitSynchronization result to 0xC920181A.
-
     // Clean up the list of client threads with pending requests, they are unneeded now that the
     // client endpoint is closed.
     pending_requesting_threads.clear();

src/core/hle/kernel/server_session.h

@@ -46,7 +46,7 @@ public:
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::ServerSession;
+    static constexpr HandleType HANDLE_TYPE = HandleType::ServerSession;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/shared_memory.h

@@ -76,7 +76,7 @@ public:
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::SharedMemory;
+    static constexpr HandleType HANDLE_TYPE = HandleType::SharedMemory;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/svc.h

@@ -6,8 +6,12 @@
 
 #include "common/common_types.h"
 
+namespace Core {
+class System;
+}
+
 namespace Kernel {
 
-void CallSVC(u32 immediate);
+void CallSVC(Core::System& system, u32 immediate);
 
 } // namespace Kernel

src/core/hle/kernel/svc_wrap.h

@@ -11,278 +11,319 @@
 
 namespace Kernel {
 
-static inline u64 Param(int n) {
-    return Core::CurrentArmInterface().GetReg(n);
+static inline u64 Param(const Core::System& system, int n) {
+    return system.CurrentArmInterface().GetReg(n);
 }
 
 /**
  * HLE a function return from the current ARM userland process
- * @param res Result to return
+ * @param system System context
+ * @param result Result to return
  */
-static inline void FuncReturn(u64 res) {
-    Core::CurrentArmInterface().SetReg(0, res);
+static inline void FuncReturn(Core::System& system, u64 result) {
+    system.CurrentArmInterface().SetReg(0, result);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type ResultCode
 
-template <ResultCode func(u64)>
-void SvcWrap() {
-    FuncReturn(func(Param(0)).raw);
+template <ResultCode func(Core::System&, u64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0)).raw);
 }
 
-template <ResultCode func(u32)>
-void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0))).raw);
+template <ResultCode func(Core::System&, u32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
 }
 
-template <ResultCode func(u32, u32)>
-void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), static_cast<u32>(Param(1))).raw);
+template <ResultCode func(Core::System&, u32, u32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(
+        system,
+        func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw);
 }
 
-template <ResultCode func(u32*)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32, u64, u64, u64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
+                            Param(system, 2), Param(system, 3))
+                           .raw);
+}
+
+template <ResultCode func(Core::System&, u32*)>
+void SvcWrap(Core::System& system) {
     u32 param = 0;
-    const u32 retval = func(&param).raw;
-    Core::CurrentArmInterface().SetReg(1, param);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param).raw;
+    system.CurrentArmInterface().SetReg(1, param);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u32*, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32*, u32)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
-    u32 retval = func(&param_1, static_cast<u32>(Param(1))).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u32*, u32*)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32*, u32*)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
     u32 param_2 = 0;
-    const u32 retval = func(&param_1, &param_2).raw;
+    const u32 retval = func(system, &param_1, &param_2).raw;
 
-    auto& arm_interface = Core::CurrentArmInterface();
+    auto& arm_interface = system.CurrentArmInterface();
     arm_interface.SetReg(1, param_1);
     arm_interface.SetReg(2, param_2);
 
-    FuncReturn(retval);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u32*, u64)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32*, u64)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
-    const u32 retval = func(&param_1, Param(1)).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, Param(system, 1)).raw;
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u32*, u64, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32*, u64, u32)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
-    const u32 retval = func(&param_1, Param(1), static_cast<u32>(Param(2))).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval =
+        func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2))).raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u64*, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u64*, u32)>
+void SvcWrap(Core::System& system) {
     u64 param_1 = 0;
-    const u32 retval = func(&param_1, static_cast<u32>(Param(1))).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u64, s32)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), static_cast<s32>(Param(1))).raw);
+template <ResultCode func(Core::System&, u64, s32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), static_cast<s32>(Param(system, 1))).raw);
 }
 
-template <ResultCode func(u64, u32)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), static_cast<u32>(Param(1))).raw);
+template <ResultCode func(Core::System&, u64, u32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1))).raw);
 }
 
-template <ResultCode func(u64*, u64)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u64*, u64)>
+void SvcWrap(Core::System& system) {
     u64 param_1 = 0;
-    u32 retval = func(&param_1, Param(1)).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, Param(system, 1)).raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u64*, u32, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u64*, u32, u32)>
+void SvcWrap(Core::System& system) {
     u64 param_1 = 0;
-    u32 retval = func(&param_1, static_cast<u32>(Param(1)), static_cast<u32>(Param(2))).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1)),
+                            static_cast<u32>(Param(system, 2)))
+                           .raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u32, u64)>
-void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), Param(1)).raw);
+template <ResultCode func(Core::System&, u32, u64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1)).raw);
 }
 
-template <ResultCode func(u32, u32, u64)>
-void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), static_cast<u32>(Param(1)), Param(2)).raw);
+template <ResultCode func(Core::System&, u32, u32, u64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)),
+                            static_cast<u32>(Param(system, 1)), Param(system, 2))
+                           .raw);
 }
 
-template <ResultCode func(u32, u32*, u64*)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32, u32*, u64*)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
     u64 param_2 = 0;
-    ResultCode retval = func(static_cast<u32>(Param(2)), &param_1, &param_2);
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    Core::CurrentArmInterface().SetReg(2, param_2);
-    FuncReturn(retval.raw);
+    const ResultCode retval = func(system, static_cast<u32>(Param(system, 2)), &param_1, &param_2);
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    system.CurrentArmInterface().SetReg(2, param_2);
+    FuncReturn(system, retval.raw);
 }
 
-template <ResultCode func(u64, u64, u32, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u64, u64, u32, u32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
+                            static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
+                           .raw);
+}
+
+template <ResultCode func(Core::System&, u64, u64, u32, u64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
+                            static_cast<u32>(Param(system, 2)), Param(system, 3))
+                           .raw);
+}
+
+template <ResultCode func(Core::System&, u32, u64, u32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
+                            static_cast<u32>(Param(system, 2)))
+                           .raw);
+}
+
+template <ResultCode func(Core::System&, u64, u64, u64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), Param(system, 1), Param(system, 2)).raw);
+}
+
+template <ResultCode func(Core::System&, u64, u64, u32)>
+void SvcWrap(Core::System& system) {
     FuncReturn(
-        func(Param(0), Param(1), static_cast<u32>(Param(2)), static_cast<u32>(Param(3))).raw);
+        system,
+        func(system, Param(system, 0), Param(system, 1), static_cast<u32>(Param(system, 2))).raw);
 }
 
-template <ResultCode func(u64, u64, u32, u64)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), Param(1), static_cast<u32>(Param(2)), Param(3)).raw);
+template <ResultCode func(Core::System&, u32, u64, u64, u32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
+                            Param(system, 2), static_cast<u32>(Param(system, 3)))
+                           .raw);
 }
 
-template <ResultCode func(u32, u64, u32)>
-void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), Param(1), static_cast<u32>(Param(2))).raw);
-}
-
-template <ResultCode func(u64, u64, u64)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), Param(1), Param(2)).raw);
-}
-
-template <ResultCode func(u64, u64, u32)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), Param(1), static_cast<u32>(Param(2))).raw);
-}
-
-template <ResultCode func(u32, u64, u64, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32, u64, u64)>
+void SvcWrap(Core::System& system) {
     FuncReturn(
-        func(static_cast<u32>(Param(0)), Param(1), Param(2), static_cast<u32>(Param(3))).raw);
+        system,
+        func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2)).raw);
 }
 
-template <ResultCode func(u32, u64, u64)>
-void SvcWrap() {
-    FuncReturn(func(static_cast<u32>(Param(0)), Param(1), Param(2)).raw);
-}
-
-template <ResultCode func(u32*, u64, u64, s64)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32*, u64, u64, s64)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
-    ResultCode retval =
-        func(&param_1, Param(1), static_cast<u32>(Param(2)), static_cast<s64>(Param(3)));
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval.raw);
+    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
+                            static_cast<s64>(Param(system, 3)))
+                           .raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u64, u64, u32, s64)>
-void SvcWrap() {
-    FuncReturn(
-        func(Param(0), Param(1), static_cast<u32>(Param(2)), static_cast<s64>(Param(3))).raw);
+template <ResultCode func(Core::System&, u64, u64, u32, s64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
+                            static_cast<u32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
+                           .raw);
 }
 
-template <ResultCode func(u64*, u64, u64, u64)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u64*, u64, u64, u64)>
+void SvcWrap(Core::System& system) {
     u64 param_1 = 0;
-    u32 retval = func(&param_1, Param(1), Param(2), Param(3)).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval =
+        func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3)).raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u32*, u64, u64, u64, u32, s32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32*, u64, u64, u64, u32, s32)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
-    u32 retval = func(&param_1, Param(1), Param(2), Param(3), static_cast<u32>(Param(4)),
-                      static_cast<s32>(Param(5)))
-                     .raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3),
+                            static_cast<u32>(Param(system, 4)), static_cast<s32>(Param(system, 5)))
+                           .raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u32*, u64, u64, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, u32*, u64, u64, u32)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
-    u32 retval = func(&param_1, Param(1), Param(2), static_cast<u32>(Param(3))).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2),
+                            static_cast<u32>(Param(system, 3)))
+                           .raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(Handle*, u64, u32, u32)>
-void SvcWrap() {
+template <ResultCode func(Core::System&, Handle*, u64, u32, u32)>
+void SvcWrap(Core::System& system) {
     u32 param_1 = 0;
-    u32 retval =
-        func(&param_1, Param(1), static_cast<u32>(Param(2)), static_cast<u32>(Param(3))).raw;
-    Core::CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(retval);
+    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
+                            static_cast<u32>(Param(system, 3)))
+                           .raw;
+
+    system.CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(system, retval);
 }
 
-template <ResultCode func(u64, u32, s32, s64)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), static_cast<u32>(Param(1)), static_cast<s32>(Param(2)),
-                    static_cast<s64>(Param(3)))
-                   .raw);
+template <ResultCode func(Core::System&, u64, u32, s32, s64)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
+                            static_cast<s32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
+                           .raw);
 }
 
-template <ResultCode func(u64, u32, s32, s32)>
-void SvcWrap() {
-    FuncReturn(func(Param(0), static_cast<u32>(Param(1)), static_cast<s32>(Param(2)),
-                    static_cast<s32>(Param(3)))
-                   .raw);
+template <ResultCode func(Core::System&, u64, u32, s32, s32)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
+                            static_cast<s32>(Param(system, 2)), static_cast<s32>(Param(system, 3)))
+                           .raw);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type u32
 
-template <u32 func()>
-void SvcWrap() {
-    FuncReturn(func());
+template <u32 func(Core::System&)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type u64
 
-template <u64 func()>
-void SvcWrap() {
-    FuncReturn(func());
+template <u64 func(Core::System&)>
+void SvcWrap(Core::System& system) {
+    FuncReturn(system, func(system));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 /// Function wrappers that return type void
 
-template <void func()>
-void SvcWrap() {
-    func();
+template <void func(Core::System&)>
+void SvcWrap(Core::System& system) {
+    func(system);
 }
 
-template <void func(s64)>
-void SvcWrap() {
-    func(static_cast<s64>(Param(0)));
+template <void func(Core::System&, s64)>
+void SvcWrap(Core::System& system) {
+    func(system, static_cast<s64>(Param(system, 0)));
 }
 
-template <void func(u64, u64 len)>
-void SvcWrap() {
-    func(Param(0), Param(1));
+template <void func(Core::System&, u64, u64)>
+void SvcWrap(Core::System& system) {
+    func(system, Param(system, 0), Param(system, 1));
 }
 
-template <void func(u64, u64, u64)>
-void SvcWrap() {
-    func(Param(0), Param(1), Param(2));
+template <void func(Core::System&, u64, u64, u64)>
+void SvcWrap(Core::System& system) {
+    func(system, Param(system, 0), Param(system, 1), Param(system, 2));
 }
 
-template <void func(u32, u64, u64)>
-void SvcWrap() {
-    func(static_cast<u32>(Param(0)), Param(1), Param(2));
+template <void func(Core::System&, u32, u64, u64)>
+void SvcWrap(Core::System& system) {
+    func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2));
 }
 
 } // namespace Kernel

src/core/hle/kernel/thread.cpp

@@ -101,8 +101,7 @@ void Thread::ResumeFromWait() {
     ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects");
 
     switch (status) {
-    case ThreadStatus::WaitSynchAll:
-    case ThreadStatus::WaitSynchAny:
+    case ThreadStatus::WaitSynch:
     case ThreadStatus::WaitHLEEvent:
     case ThreadStatus::WaitSleep:
     case ThreadStatus::WaitIPC:
@@ -142,6 +141,12 @@ void Thread::ResumeFromWait() {
     ChangeScheduler();
 }
 
+void Thread::CancelWait() {
+    ASSERT(GetStatus() == ThreadStatus::WaitSynch);
+    SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
+    ResumeFromWait();
+}
+
 /**
  * Resets a thread context, making it ready to be scheduled and run by the CPU
  * @param context Thread context to reset
@@ -220,11 +225,6 @@ void Thread::SetPriority(u32 priority) {
     UpdatePriority();
 }
 
-void Thread::BoostPriority(u32 priority) {
-    scheduler->SetThreadPriority(this, priority);
-    current_priority = priority;
-}
-
 void Thread::SetWaitSynchronizationResult(ResultCode result) {
     context.cpu_registers[0] = result.raw;
 }

src/core/hle/kernel/thread.h

@@ -49,8 +49,7 @@ enum class ThreadStatus {
     WaitHLEEvent, ///< Waiting for hle event to finish
     WaitSleep,    ///< Waiting due to a SleepThread SVC
     WaitIPC,      ///< Waiting for the reply from an IPC request
-    WaitSynchAny, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
-    WaitSynchAll, ///< Waiting due to WaitSynchronizationN with wait_all = true
+    WaitSynch,    ///< Waiting due to WaitSynchronization
     WaitMutex,    ///< Waiting due to an ArbitrateLock svc
     WaitCondVar,  ///< Waiting due to an WaitProcessWideKey svc
     WaitArb,      ///< Waiting due to a SignalToAddress/WaitForAddress svc
@@ -102,11 +101,16 @@ public:
     std::string GetName() const override {
         return name;
     }
+
+    void SetName(std::string new_name) {
+        name = std::move(new_name);
+    }
+
     std::string GetTypeName() const override {
         return "Thread";
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::Thread;
+    static constexpr HandleType HANDLE_TYPE = HandleType::Thread;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
@@ -136,12 +140,6 @@ public:
      */
     void SetPriority(u32 priority);
 
-    /**
-     * Temporarily boosts the thread's priority until the next time it is scheduled
-     * @param priority The new priority
-     */
-    void BoostPriority(u32 priority);
-
     /// Adds a thread to the list of threads that are waiting for a lock held by this thread.
     void AddMutexWaiter(SharedPtr<Thread> thread);
 
@@ -170,11 +168,17 @@ public:
         return tls_memory;
     }
 
-    /**
-     * Resumes a thread from waiting
-     */
+    /// Resumes a thread from waiting
     void ResumeFromWait();
 
+    /// Cancels a waiting operation that this thread may or may not be within.
+    ///
+    /// When the thread is within a waiting state, this will set the thread's
+    /// waiting result to signal a canceled wait. The function will then resume
+    /// this thread.
+    ///
+    void CancelWait();
+
     /**
      * Schedules an event to wake up the specified thread after the specified delay
      * @param nanoseconds The time this thread will be allowed to sleep for
@@ -185,24 +189,27 @@ public:
     void CancelWakeupTimer();
 
     /**
-     * Sets the result after the thread awakens (from either WaitSynchronization SVC)
+     * Sets the result after the thread awakens (from svcWaitSynchronization)
      * @param result Value to set to the returned result
      */
     void SetWaitSynchronizationResult(ResultCode result);
 
     /**
-     * Sets the output parameter value after the thread awakens (from WaitSynchronizationN SVC only)
+     * Sets the output parameter value after the thread awakens (from svcWaitSynchronization)
      * @param output Value to set to the output parameter
      */
     void SetWaitSynchronizationOutput(s32 output);
 
     /**
      * Retrieves the index that this particular object occupies in the list of objects
-     * that the thread passed to WaitSynchronizationN, starting the search from the last element.
-     * It is used to set the output value of WaitSynchronizationN when the thread is awakened.
+     * that the thread passed to WaitSynchronization, starting the search from the last element.
+     *
+     * It is used to set the output index of WaitSynchronization when the thread is awakened.
+     *
      * When a thread wakes up due to an object signal, the kernel will use the index of the last
      * matching object in the wait objects list in case of having multiple instances of the same
      * object in the list.
+     *
      * @param object Object to query the index of.
      */
     s32 GetWaitObjectIndex(const WaitObject* object) const;
@@ -239,13 +246,9 @@ public:
      */
     VAddr GetCommandBufferAddress() const;
 
-    /**
-     * Returns whether this thread is waiting for all the objects in
-     * its wait list to become ready, as a result of a WaitSynchronizationN call
-     * with wait_all = true.
-     */
-    bool IsSleepingOnWaitAll() const {
-        return status == ThreadStatus::WaitSynchAll;
+    /// Returns whether this thread is waiting on objects from a WaitSynchronization call.
+    bool IsSleepingOnWait() const {
+        return status == ThreadStatus::WaitSynch;
     }
 
     ThreadContext& GetContext() {
@@ -345,10 +348,6 @@ public:
         arb_wait_address = address;
     }
 
-    void SetGuestHandle(Handle handle) {
-        guest_handle = handle;
-    }
-
     bool HasWakeupCallback() const {
         return wakeup_callback != nullptr;
     }
@@ -423,7 +422,7 @@ private:
     Process* owner_process;
 
     /// Objects that the thread is waiting on, in the same order as they were
-    /// passed to WaitSynchronization1/N.
+    /// passed to WaitSynchronization.
     ThreadWaitObjects wait_objects;
 
     /// List of threads that are waiting for a mutex that is held by this thread.
@@ -442,14 +441,11 @@ private:
     /// If waiting for an AddressArbiter, this is the address being waited on.
     VAddr arb_wait_address{0};
 
-    /// Handle used by guest emulated application to access this thread
-    Handle guest_handle = 0;
-
     /// Handle used as userdata to reference this object when inserting into the CoreTiming queue.
     Handle callback_handle = 0;
 
     /// Callback that will be invoked when the thread is resumed from a waiting state. If the thread
-    /// was waiting via WaitSynchronizationN then the object will be the last object that became
+    /// was waiting via WaitSynchronization then the object will be the last object that became
     /// available. In case of a timeout, the object will be nullptr.
     WakeupCallback wakeup_callback;
 

src/core/hle/kernel/vm_manager.cpp

@@ -62,7 +62,7 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
     return true;
 }
 
-VMManager::VMManager() {
+VMManager::VMManager(Core::System& system) : system{system} {
     // Default to assuming a 39-bit address space. This way we have a sane
     // starting point with executables that don't provide metadata.
     Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
@@ -111,7 +111,6 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
-    auto& system = Core::System::GetInstance();
     system.ArmInterface(0).MapBackingMemory(target, size, block->data() + offset,
                                             VMAPermission::ReadWriteExecute);
     system.ArmInterface(1).MapBackingMemory(target, size, block->data() + offset,
@@ -140,7 +139,6 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
-    auto& system = Core::System::GetInstance();
     system.ArmInterface(0).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
     system.ArmInterface(1).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
     system.ArmInterface(2).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
@@ -223,7 +221,6 @@ ResultCode VMManager::UnmapRange(VAddr target, u64 size) {
 
     ASSERT(FindVMA(target)->second.size >= size);
 
-    auto& system = Core::System::GetInstance();
     system.ArmInterface(0).UnmapMemory(target, size);
     system.ArmInterface(1).UnmapMemory(target, size);
     system.ArmInterface(2).UnmapMemory(target, size);
@@ -302,6 +299,86 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
     return MakeResult<VAddr>(heap_region_base);
 }
 
+ResultCode VMManager::MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
+    constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
+    const auto src_check_result = CheckRangeState(
+        src_address, size, MemoryState::All, MemoryState::Heap, VMAPermission::All,
+        VMAPermission::ReadWrite, MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
+
+    if (src_check_result.Failed()) {
+        return src_check_result.Code();
+    }
+
+    const auto mirror_result =
+        MirrorMemory(dst_address, src_address, size, MemoryState::ModuleCode);
+    if (mirror_result.IsError()) {
+        return mirror_result;
+    }
+
+    // Ensure we lock the source memory region.
+    const auto src_vma_result = CarveVMARange(src_address, size);
+    if (src_vma_result.Failed()) {
+        return src_vma_result.Code();
+    }
+    auto src_vma_iter = *src_vma_result;
+    src_vma_iter->second.attribute = MemoryAttribute::Locked;
+    Reprotect(src_vma_iter, VMAPermission::Read);
+
+    // The destination memory region is fine as is, however we need to make it read-only.
+    return ReprotectRange(dst_address, size, VMAPermission::Read);
+}
+
+ResultCode VMManager::UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
+    constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
+    const auto src_check_result = CheckRangeState(
+        src_address, size, MemoryState::All, MemoryState::Heap, VMAPermission::None,
+        VMAPermission::None, MemoryAttribute::Mask, MemoryAttribute::Locked, ignore_attribute);
+
+    if (src_check_result.Failed()) {
+        return src_check_result.Code();
+    }
+
+    // Yes, the kernel only checks the first page of the region.
+    const auto dst_check_result =
+        CheckRangeState(dst_address, Memory::PAGE_SIZE, MemoryState::FlagModule,
+                        MemoryState::FlagModule, VMAPermission::None, VMAPermission::None,
+                        MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
+
+    if (dst_check_result.Failed()) {
+        return dst_check_result.Code();
+    }
+
+    const auto dst_memory_state = std::get<MemoryState>(*dst_check_result);
+    const auto dst_contiguous_check_result = CheckRangeState(
+        dst_address, size, MemoryState::All, dst_memory_state, VMAPermission::None,
+        VMAPermission::None, MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
+
+    if (dst_contiguous_check_result.Failed()) {
+        return dst_contiguous_check_result.Code();
+    }
+
+    const auto unmap_result = UnmapRange(dst_address, size);
+    if (unmap_result.IsError()) {
+        return unmap_result;
+    }
+
+    // With the mirrored portion unmapped, restore the original region's traits.
+    const auto src_vma_result = CarveVMARange(src_address, size);
+    if (src_vma_result.Failed()) {
+        return src_vma_result.Code();
+    }
+    auto src_vma_iter = *src_vma_result;
+    src_vma_iter->second.state = MemoryState::Heap;
+    src_vma_iter->second.attribute = MemoryAttribute::None;
+    Reprotect(src_vma_iter, VMAPermission::ReadWrite);
+
+    if (dst_memory_state == MemoryState::ModuleCode) {
+        system.InvalidateCpuInstructionCaches();
+    }
+
+    return unmap_result;
+}
+
 MemoryInfo VMManager::QueryMemory(VAddr address) const {
     const auto vma = FindVMA(address);
     MemoryInfo memory_info{};

src/core/hle/kernel/vm_manager.h

@@ -14,6 +14,10 @@
 #include "core/hle/result.h"
 #include "core/memory.h"
 
+namespace Core {
+class System;
+}
+
 namespace FileSys {
 enum class ProgramAddressSpaceType : u8;
 }
@@ -43,6 +47,9 @@ enum class VMAPermission : u8 {
     ReadExecute = Read | Execute,
     WriteExecute = Write | Execute,
     ReadWriteExecute = Read | Write | Execute,
+
+    // Used as a wildcard when checking permissions across memory ranges
+    All = 0xFF,
 };
 
 constexpr VMAPermission operator|(VMAPermission lhs, VMAPermission rhs) {
@@ -152,6 +159,9 @@ enum class MemoryState : u32 {
     FlagUncached                    = 1U << 24,
     FlagCodeMemory                  = 1U << 25,
 
+    // Wildcard used in range checking to indicate all states.
+    All                             = 0xFFFFFFFF,
+
     // Convenience flag sets to reduce repetition
     IPCFlags = FlagIPC0 | FlagIPC3 | FlagIPC1,
 
@@ -315,7 +325,7 @@ class VMManager final {
 public:
     using VMAHandle = VMAMap::const_iterator;
 
-    VMManager();
+    explicit VMManager(Core::System& system);
     ~VMManager();
 
     /// Clears the address space map, re-initializing with a single free area.
@@ -415,6 +425,49 @@ public:
     ///
     ResultVal<VAddr> SetHeapSize(u64 size);
 
+    /// Maps a region of memory as code memory.
+    ///
+    /// @param dst_address The base address of the region to create the aliasing memory region.
+    /// @param src_address The base address of the region to be aliased.
+    /// @param size        The total amount of memory to map in bytes.
+    ///
+    /// @pre Both memory regions lie within the actual addressable address space.
+    ///
+    /// @post After this function finishes execution, assuming success, then the address range
+    ///       [dst_address, dst_address+size) will alias the memory region,
+    ///       [src_address, src_address+size).
+    ///       <p>
+    ///       What this also entails is as follows:
+    ///          1. The aliased region gains the Locked memory attribute.
+    ///          2. The aliased region becomes read-only.
+    ///          3. The aliasing region becomes read-only.
+    ///          4. The aliasing region is created with a memory state of MemoryState::CodeModule.
+    ///
+    ResultCode MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size);
+
+    /// Unmaps a region of memory designated as code module memory.
+    ///
+    /// @param dst_address The base address of the memory region aliasing the source memory region.
+    /// @param src_address The base address of the memory region being aliased.
+    /// @param size        The size of the memory region to unmap in bytes.
+    ///
+    /// @pre Both memory ranges lie within the actual addressable address space.
+    ///
+    /// @pre The memory region being unmapped has been previously been mapped
+    ///      by a call to MapCodeMemory.
+    ///
+    /// @post After execution of the function, if successful. the aliasing memory region
+    ///       will be unmapped and the aliased region will have various traits about it
+    ///       restored to what they were prior to the original mapping call preceding
+    ///       this function call.
+    ///       <p>
+    ///       What this also entails is as follows:
+    ///           1. The state of the memory region will now indicate a general heap region.
+    ///           2. All memory attributes for the memory region are cleared.
+    ///           3. Memory permissions for the region are restored to user read/write.
+    ///
+    ResultCode UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64 size);
+
     /// Queries the memory manager for information about the given address.
     ///
     /// @param address The address to query the memory manager about for information.
@@ -663,5 +716,7 @@ private:
     // The end of the currently allocated heap. This is not an inclusive
     // end of the range. This is essentially 'base_address + current_size'.
     VAddr heap_end = 0;
+
+    Core::System& system;
 };
 } // namespace Kernel

src/core/hle/kernel/wait_object.cpp

@@ -30,7 +30,7 @@ void WaitObject::RemoveWaitingThread(Thread* thread) {
         waiting_threads.erase(itr);
 }
 
-SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
+SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
     Thread* candidate = nullptr;
     u32 candidate_priority = THREADPRIO_LOWEST + 1;
 
@@ -38,8 +38,7 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
         const ThreadStatus thread_status = thread->GetStatus();
 
         // The list of waiting threads must not contain threads that are not waiting to be awakened.
-        ASSERT_MSG(thread_status == ThreadStatus::WaitSynchAny ||
-                       thread_status == ThreadStatus::WaitSynchAll ||
+        ASSERT_MSG(thread_status == ThreadStatus::WaitSynch ||
                        thread_status == ThreadStatus::WaitHLEEvent,
                    "Inconsistent thread statuses in waiting_threads");
 
@@ -49,10 +48,10 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
         if (ShouldWait(thread.get()))
             continue;
 
-        // A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
-        // in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
+        // A thread is ready to run if it's either in ThreadStatus::WaitSynch
+        // and the rest of the objects it is waiting on are ready.
         bool ready_to_run = true;
-        if (thread_status == ThreadStatus::WaitSynchAll) {
+        if (thread_status == ThreadStatus::WaitSynch) {
             ready_to_run = thread->AllWaitObjectsReady();
         }
 
@@ -68,33 +67,35 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
 void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
     ASSERT(!ShouldWait(thread.get()));
 
-    if (!thread)
+    if (!thread) {
         return;
+    }
 
-    if (!thread->IsSleepingOnWaitAll()) {
-        Acquire(thread.get());
-    } else {
+    if (thread->IsSleepingOnWait()) {
         for (const auto& object : thread->GetWaitObjects()) {
             ASSERT(!object->ShouldWait(thread.get()));
             object->Acquire(thread.get());
         }
+    } else {
+        Acquire(thread.get());
     }
 
     const std::size_t index = thread->GetWaitObjectIndex(this);
 
-    for (const auto& object : thread->GetWaitObjects())
+    for (const auto& object : thread->GetWaitObjects()) {
         object->RemoveWaitingThread(thread.get());
+    }
     thread->ClearWaitObjects();
 
     thread->CancelWakeupTimer();
 
     bool resume = true;
-
-    if (thread->HasWakeupCallback())
+    if (thread->HasWakeupCallback()) {
         resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, this, index);
-
-    if (resume)
+    }
+    if (resume) {
         thread->ResumeFromWait();
+    }
 }
 
 void WaitObject::WakeupAllWaitingThreads() {

src/core/hle/kernel/wait_object.h

@@ -54,7 +54,7 @@ public:
     void WakeupWaitingThread(SharedPtr<Thread> thread);
 
     /// Obtains the highest priority thread that is ready to run from this object's waiting list.
-    SharedPtr<Thread> GetHighestPriorityReadyThread();
+    SharedPtr<Thread> GetHighestPriorityReadyThread() const;
 
     /// Get a const reference to the waiting threads list for debug use
     const std::vector<SharedPtr<Thread>>& GetWaitingThreads() const;

src/core/hle/kernel/writable_event.h

@@ -37,7 +37,7 @@ public:
         return name;
     }
 
-    static const HandleType HANDLE_TYPE = HandleType::WritableEvent;
+    static constexpr HandleType HANDLE_TYPE = HandleType::WritableEvent;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

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

@@ -137,6 +137,7 @@ private:
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
     IManagerForApplication() : ServiceFramework("IManagerForApplication") {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
             {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
@@ -145,7 +146,10 @@ public:
             {130, nullptr, "GetNintendoAccountUserResourceCacheForApplication"},
             {150, nullptr, "CreateAuthorizationRequest"},
             {160, nullptr, "StoreOpenContext"},
+            {170, nullptr, "LoadNetworkServiceLicenseKindAsync"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 

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

@@ -8,6 +8,7 @@ namespace Service::Account {
 
 ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:su") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_SU::GetUserCount, "GetUserCount"},
         {1, &ACC_SU::GetUserExistence, "GetUserExistence"},
@@ -19,6 +20,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_SU::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
+        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
         {102, nullptr, "GetBaasAccountManagerForSystemService"},
@@ -29,6 +31,8 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},
         {113, nullptr, "GetSaveDataThumbnailExistence"},
+        {130, nullptr, "ActivateOpenContextRetention"},
+        {140, nullptr, "ListQualifiedUsers"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},
         {200, nullptr, "BeginUserRegistration"},
@@ -48,6 +52,8 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {998, nullptr, "DebugSetUserStateClose"},
         {999, nullptr, "DebugSetUserStateOpen"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 

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

@@ -8,6 +8,7 @@ namespace Service::Account {
 
 ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:u0") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U0::GetUserCount, "GetUserCount"},
         {1, &ACC_U0::GetUserExistence, "GetUserExistence"},
@@ -19,6 +20,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
+        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
         {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
         {102, nullptr, "AuthenticateApplicationAsync"},
@@ -27,7 +29,13 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {120, nullptr, "CreateGuestLoginRequest"},
         {130, nullptr, "LoadOpenContext"},
+        {131, nullptr, "ListOpenContextStoredUsers"},
+        {140, nullptr, "InitializeApplicationInfo"},
+        {141, nullptr, "ListQualifiedUsers"},
+        {150, nullptr, "IsUserAccountSwitchLocked"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 

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

@@ -8,6 +8,7 @@ namespace Service::Account {
 
 ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:u1") {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U1::GetUserCount, "GetUserCount"},
         {1, &ACC_U1::GetUserExistence, "GetUserExistence"},
@@ -19,6 +20,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
+        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
         {102, nullptr, "GetBaasAccountManagerForSystemService"},
@@ -29,12 +31,16 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},
         {113, nullptr, "GetSaveDataThumbnailExistence"},
+        {130, nullptr, "ActivateOpenContextRetention"},
+        {140, nullptr, "ListQualifiedUsers"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},
         {997, nullptr, "DebugInvalidateTokenCacheForUser"},
         {998, nullptr, "DebugSetUserStateClose"},
         {999, nullptr, "DebugSetUserStateOpen"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 }
 

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

@@ -22,7 +22,6 @@
 #include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/am/applets/profile_select.h"
 #include "core/hle/service/am/applets/software_keyboard.h"
-#include "core/hle/service/am/applets/stub_applet.h"
 #include "core/hle/service/am/applets/web_browser.h"
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
@@ -42,12 +41,6 @@ constexpr ResultCode ERR_NO_DATA_IN_CHANNEL{ErrorModule::AM, 0x2};
 constexpr ResultCode ERR_NO_MESSAGES{ErrorModule::AM, 0x3};
 constexpr ResultCode ERR_SIZE_OUT_OF_BOUNDS{ErrorModule::AM, 0x1F7};
 
-enum class AppletId : u32 {
-    ProfileSelect = 0x10,
-    SoftwareKeyboard = 0x11,
-    LibAppletOff = 0x17,
-};
-
 constexpr u32 POP_LAUNCH_PARAMETER_MAGIC = 0xC79497CA;
 
 struct LaunchParameters {
@@ -224,6 +217,7 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework{"IDebugFunctions"} {
         {20, nullptr, "InvalidateTransitionLayer"},
         {30, nullptr, "RequestLaunchApplicationWithUserAndArgumentForDebug"},
         {40, nullptr, "GetAppletResourceUsageInfo"},
+        {41, nullptr, "SetCpuBoostModeForApplet"},
     };
     // clang-format on
 
@@ -256,6 +250,7 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
         {41, nullptr, "IsSystemBufferSharingEnabled"},
         {42, nullptr, "GetSystemSharedLayerHandle"},
+        {43, nullptr, "GetSystemSharedBufferHandle"},
         {50, &ISelfController::SetHandlesRequestToDisplay, "SetHandlesRequestToDisplay"},
         {51, nullptr, "ApproveToDisplay"},
         {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
@@ -269,9 +264,11 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {68, nullptr, "SetAutoSleepDisabled"},
         {69, nullptr, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
+        {71, nullptr, "GetCurrentIlluminanceEx"},
         {80, nullptr, "SetWirelessPriorityMode"},
         {90, nullptr, "GetAccumulatedSuspendedTickValue"},
         {91, nullptr, "GetAccumulatedSuspendedTickChangedEvent"},
+        {100, nullptr, "SetAlbumImageTakenNotificationEnabled"},
         {1000, nullptr, "GetDebugStorageChannel"},
     };
     // clang-format on
@@ -516,11 +513,20 @@ ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_q
         {50, nullptr, "IsVrModeEnabled"},
         {51, nullptr, "SetVrModeEnabled"},
         {52, nullptr, "SwitchLcdBacklight"},
+        {53, nullptr, "BeginVrModeEx"},
+        {54, nullptr, "EndVrModeEx"},
         {55, nullptr, "IsInControllerFirmwareUpdateSection"},
         {60, &ICommonStateGetter::GetDefaultDisplayResolution, "GetDefaultDisplayResolution"},
         {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent, "GetDefaultDisplayResolutionChangeEvent"},
         {62, nullptr, "GetHdcpAuthenticationState"},
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
+        {64, nullptr, "SetTvPowerStateMatchingMode"},
+        {65, nullptr, "GetApplicationIdByContentActionName"},
+        {66, nullptr, "SetCpuBoostMode"},
+        {80, nullptr, "PerformSystemButtonPressingIfInFocus"},
+        {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
+        {91, nullptr, "GetCurrentPerformanceConfiguration"},
+        {200, nullptr, "GetOperationModeSystemInfo"},
     };
     // clang-format on
 
@@ -873,30 +879,16 @@ ILibraryAppletCreator::ILibraryAppletCreator() : ServiceFramework("ILibraryApple
 
 ILibraryAppletCreator::~ILibraryAppletCreator() = default;
 
-static std::shared_ptr<Applets::Applet> GetAppletFromId(AppletId id) {
-    switch (id) {
-    case AppletId::ProfileSelect:
-        return std::make_shared<Applets::ProfileSelect>();
-    case AppletId::SoftwareKeyboard:
-        return std::make_shared<Applets::SoftwareKeyboard>();
-    case AppletId::LibAppletOff:
-        return std::make_shared<Applets::WebBrowser>();
-    default:
-        LOG_ERROR(Service_AM, "Unimplemented AppletId [{:08X}]! -- Falling back to stub!",
-                  static_cast<u32>(id));
-        return std::make_shared<Applets::StubApplet>();
-    }
-}
-
 void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto applet_id = rp.PopRaw<AppletId>();
+    const auto applet_id = rp.PopRaw<Applets::AppletId>();
     const auto applet_mode = rp.PopRaw<u32>();
 
     LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}",
               static_cast<u32>(applet_id), applet_mode);
 
-    const auto applet = GetAppletFromId(applet_id);
+    const auto& applet_manager{Core::System::GetInstance().GetAppletManager()};
+    const auto applet = applet_manager.GetApplet(applet_id);
 
     if (applet == nullptr) {
         LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
@@ -960,6 +952,8 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
         {12, nullptr, "CreateApplicationAndRequestToStart"},
         {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest, "CreateApplicationAndRequestToStartForQuest"},
+        {14, nullptr, "CreateApplicationWithAttributeAndPushAndRequestToStartForQuest"},
+        {15, nullptr, "CreateApplicationWithAttributeAndRequestToStartForQuest"},
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
@@ -1233,6 +1227,7 @@ IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStat
         {2, nullptr, "StartSleepSequence"},
         {3, nullptr, "StartShutdownSequence"},
         {4, nullptr, "StartRebootSequence"},
+        {9, nullptr, "IsAutoPowerDownRequested"},
         {10, nullptr, "LoadAndApplyIdlePolicySettings"},
         {11, nullptr, "NotifyCecSettingsChanged"},
         {12, nullptr, "SetDefaultHomeButtonLongPressTime"},

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

@@ -16,6 +16,7 @@ public:
                                  std::shared_ptr<AppletMessageQueue> msg_queue)
         : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)),
           msg_queue(std::move(msg_queue)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &ILibraryAppletProxy::GetSelfController, "GetSelfController"},
@@ -25,8 +26,11 @@ public:
             {10, &ILibraryAppletProxy::GetProcessWindingController, "GetProcessWindingController"},
             {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
             {20, &ILibraryAppletProxy::GetApplicationFunctions, "GetApplicationFunctions"},
+            {21, nullptr, "GetAppletCommonFunctions"},
             {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 
@@ -113,6 +117,7 @@ public:
                                 std::shared_ptr<AppletMessageQueue> msg_queue)
         : ServiceFramework("ISystemAppletProxy"), nvflinger(std::move(nvflinger)),
           msg_queue(std::move(msg_queue)) {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ISystemAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &ISystemAppletProxy::GetSelfController, "GetSelfController"},
@@ -124,8 +129,11 @@ public:
             {20, &ISystemAppletProxy::GetHomeMenuFunctions, "GetHomeMenuFunctions"},
             {21, &ISystemAppletProxy::GetGlobalStateController, "GetGlobalStateController"},
             {22, &ISystemAppletProxy::GetApplicationCreator, "GetApplicationCreator"},
+            {23, nullptr, "GetAppletCommonFunctions"},
             {1000, &ISystemAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 

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

@@ -5,11 +5,21 @@
 #include <cstring>
 #include "common/assert.h"
 #include "core/core.h"
+#include "core/frontend/applets/error.h"
+#include "core/frontend/applets/general_frontend.h"
+#include "core/frontend/applets/profile_select.h"
+#include "core/frontend/applets/software_keyboard.h"
+#include "core/frontend/applets/web_browser.h"
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/am/applets/error.h"
+#include "core/hle/service/am/applets/general_backend.h"
+#include "core/hle/service/am/applets/profile_select.h"
+#include "core/hle/service/am/applets/software_keyboard.h"
+#include "core/hle/service/am/applets/web_browser.h"
 
 namespace Service::AM::Applets {
 
@@ -111,4 +121,76 @@ void Applet::Initialize() {
     initialized = true;
 }
 
+AppletManager::AppletManager() = default;
+
+AppletManager::~AppletManager() = default;
+
+void AppletManager::SetAppletFrontendSet(AppletFrontendSet set) {
+    if (set.error != nullptr)
+        frontend.error = std::move(set.error);
+    if (set.photo_viewer != nullptr)
+        frontend.photo_viewer = std::move(set.photo_viewer);
+    if (set.profile_select != nullptr)
+        frontend.profile_select = std::move(set.profile_select);
+    if (set.software_keyboard != nullptr)
+        frontend.software_keyboard = std::move(set.software_keyboard);
+    if (set.web_browser != nullptr)
+        frontend.web_browser = std::move(set.web_browser);
+}
+
+void AppletManager::SetDefaultAppletFrontendSet() {
+    frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
+    frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
+    frontend.profile_select = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
+    frontend.software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
+    frontend.web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
+}
+
+void AppletManager::SetDefaultAppletsIfMissing() {
+    if (frontend.error == nullptr) {
+        frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
+    }
+
+    if (frontend.photo_viewer == nullptr) {
+        frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
+    }
+
+    if (frontend.profile_select == nullptr) {
+        frontend.profile_select = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
+    }
+
+    if (frontend.software_keyboard == nullptr) {
+        frontend.software_keyboard =
+            std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
+    }
+
+    if (frontend.web_browser == nullptr) {
+        frontend.web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
+    }
+}
+
+void AppletManager::ClearAll() {
+    frontend = {};
+}
+
+std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id) const {
+    switch (id) {
+    case AppletId::Error:
+        return std::make_shared<Error>(*frontend.error);
+    case AppletId::ProfileSelect:
+        return std::make_shared<ProfileSelect>(*frontend.profile_select);
+    case AppletId::SoftwareKeyboard:
+        return std::make_shared<SoftwareKeyboard>(*frontend.software_keyboard);
+    case AppletId::PhotoViewer:
+        return std::make_shared<PhotoViewer>(*frontend.photo_viewer);
+    case AppletId::LibAppletOff:
+        return std::make_shared<WebBrowser>(*frontend.web_browser);
+    default:
+        UNIMPLEMENTED_MSG(
+            "No backend implementation exists for applet_id={:02X}! Falling back to stub applet.",
+            static_cast<u8>(id));
+        return std::make_shared<StubApplet>();
+    }
+}
+
 } // namespace Service::AM::Applets

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

@@ -12,12 +12,43 @@
 
 union ResultCode;
 
+namespace Core::Frontend {
+class ErrorApplet;
+class PhotoViewerApplet;
+class ProfileSelectApplet;
+class SoftwareKeyboardApplet;
+class WebBrowserApplet;
+} // namespace Core::Frontend
+
 namespace Service::AM {
 
 class IStorage;
 
 namespace Applets {
 
+enum class AppletId : u32 {
+    OverlayDisplay = 0x02,
+    QLaunch = 0x03,
+    Starter = 0x04,
+    Auth = 0x0A,
+    Cabinet = 0x0B,
+    Controller = 0x0C,
+    DataErase = 0x0D,
+    Error = 0x0E,
+    NetConnect = 0x0F,
+    ProfileSelect = 0x10,
+    SoftwareKeyboard = 0x11,
+    MiiEdit = 0x12,
+    LibAppletWeb = 0x13,
+    LibAppletShop = 0x14,
+    PhotoViewer = 0x15,
+    Settings = 0x16,
+    LibAppletOff = 0x17,
+    LibAppletWhitelisted = 0x18,
+    LibAppletAuth = 0x19,
+    MyPage = 0x1A,
+};
+
 class AppletDataBroker final {
 public:
     AppletDataBroker();
@@ -105,5 +136,29 @@ protected:
     bool initialized = false;
 };
 
+struct AppletFrontendSet {
+    std::unique_ptr<Core::Frontend::ErrorApplet> error;
+    std::unique_ptr<Core::Frontend::PhotoViewerApplet> photo_viewer;
+    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_select;
+    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
+    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
+};
+
+class AppletManager {
+public:
+    AppletManager();
+    ~AppletManager();
+
+    void SetAppletFrontendSet(AppletFrontendSet set);
+    void SetDefaultAppletFrontendSet();
+    void SetDefaultAppletsIfMissing();
+    void ClearAll();
+
+    std::shared_ptr<Applet> GetApplet(AppletId id) const;
+
+private:
+    AppletFrontendSet frontend;
+};
+
 } // namespace Applets
 } // namespace Service::AM

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

@@ -0,0 +1,182 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <array>
+#include <cstring>
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/frontend/applets/error.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/error.h"
+
+namespace Service::AM::Applets {
+
+#pragma pack(push, 4)
+struct ShowError {
+    u8 mode;
+    bool jump;
+    INSERT_PADDING_BYTES(4);
+    bool use_64bit_error_code;
+    INSERT_PADDING_BYTES(1);
+    u64 error_code_64;
+    u32 error_code_32;
+};
+static_assert(sizeof(ShowError) == 0x14, "ShowError has incorrect size.");
+#pragma pack(pop)
+
+struct ShowErrorRecord {
+    u8 mode;
+    bool jump;
+    INSERT_PADDING_BYTES(6);
+    u64 error_code_64;
+    u64 posix_time;
+};
+static_assert(sizeof(ShowErrorRecord) == 0x18, "ShowErrorRecord has incorrect size.");
+
+struct SystemErrorArg {
+    u8 mode;
+    bool jump;
+    INSERT_PADDING_BYTES(6);
+    u64 error_code_64;
+    std::array<char, 8> language_code;
+    std::array<char, 0x800> main_text;
+    std::array<char, 0x800> detail_text;
+};
+static_assert(sizeof(SystemErrorArg) == 0x1018, "SystemErrorArg has incorrect size.");
+
+struct ApplicationErrorArg {
+    u8 mode;
+    bool jump;
+    INSERT_PADDING_BYTES(6);
+    u32 error_code;
+    std::array<char, 8> language_code;
+    std::array<char, 0x800> main_text;
+    std::array<char, 0x800> detail_text;
+};
+static_assert(sizeof(ApplicationErrorArg) == 0x1014, "ApplicationErrorArg has incorrect size.");
+
+union Error::ErrorArguments {
+    ShowError error;
+    ShowErrorRecord error_record;
+    SystemErrorArg system_error;
+    ApplicationErrorArg application_error;
+};
+
+namespace {
+template <typename T>
+void CopyArgumentData(const std::vector<u8>& data, T& variable) {
+    ASSERT(data.size() >= sizeof(T));
+    std::memcpy(&variable, data.data(), sizeof(T));
+}
+
+ResultCode Decode64BitError(u64 error) {
+    const auto description = (error >> 32) & 0x1FFF;
+    auto module = error & 0x3FF;
+    if (module >= 2000)
+        module -= 2000;
+    module &= 0x1FF;
+    return {static_cast<ErrorModule>(module), static_cast<u32>(description)};
+}
+
+} // Anonymous namespace
+
+Error::Error(const Core::Frontend::ErrorApplet& frontend) : frontend(frontend) {}
+
+Error::~Error() = default;
+
+void Error::Initialize() {
+    Applet::Initialize();
+    args = std::make_unique<ErrorArguments>();
+    complete = false;
+
+    const auto storage = broker.PopNormalDataToApplet();
+    ASSERT(storage != nullptr);
+    const auto data = storage->GetData();
+
+    ASSERT(!data.empty());
+    std::memcpy(&mode, data.data(), sizeof(ErrorAppletMode));
+
+    switch (mode) {
+    case ErrorAppletMode::ShowError:
+        CopyArgumentData(data, args->error);
+        if (args->error.use_64bit_error_code) {
+            error_code = Decode64BitError(args->error.error_code_64);
+        } else {
+            error_code = ResultCode(args->error.error_code_32);
+        }
+        break;
+    case ErrorAppletMode::ShowSystemError:
+        CopyArgumentData(data, args->system_error);
+        error_code = ResultCode(Decode64BitError(args->system_error.error_code_64));
+        break;
+    case ErrorAppletMode::ShowApplicationError:
+        CopyArgumentData(data, args->application_error);
+        error_code = ResultCode(args->application_error.error_code);
+        break;
+    case ErrorAppletMode::ShowErrorRecord:
+        CopyArgumentData(data, args->error_record);
+        error_code = Decode64BitError(args->error_record.error_code_64);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
+    }
+}
+
+bool Error::TransactionComplete() const {
+    return complete;
+}
+
+ResultCode Error::GetStatus() const {
+    return RESULT_SUCCESS;
+}
+
+void Error::ExecuteInteractive() {
+    UNREACHABLE_MSG("Unexpected interactive applet data!");
+}
+
+void Error::Execute() {
+    if (complete) {
+        return;
+    }
+
+    const auto callback = [this] { DisplayCompleted(); };
+
+    switch (mode) {
+    case ErrorAppletMode::ShowError:
+        frontend.ShowError(error_code, callback);
+        break;
+    case ErrorAppletMode::ShowSystemError:
+    case ErrorAppletMode::ShowApplicationError: {
+        const auto system = mode == ErrorAppletMode::ShowSystemError;
+        const auto& main_text =
+            system ? args->system_error.main_text : args->application_error.main_text;
+        const auto& detail_text =
+            system ? args->system_error.detail_text : args->application_error.detail_text;
+
+        frontend.ShowCustomErrorText(
+            error_code,
+            Common::StringFromFixedZeroTerminatedBuffer(main_text.data(), main_text.size()),
+            Common::StringFromFixedZeroTerminatedBuffer(detail_text.data(), detail_text.size()),
+            callback);
+        break;
+    }
+    case ErrorAppletMode::ShowErrorRecord:
+        frontend.ShowErrorWithTimestamp(
+            error_code, std::chrono::seconds{args->error_record.posix_time}, callback);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
+        DisplayCompleted();
+    }
+}
+
+void Error::DisplayCompleted() {
+    complete = true;
+    broker.PushNormalDataFromApplet(IStorage{{}});
+    broker.SignalStateChanged();
+}
+
+} // namespace Service::AM::Applets

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

@@ -0,0 +1,47 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/result.h"
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Service::AM::Applets {
+
+enum class ErrorAppletMode : u8 {
+    ShowError = 0,
+    ShowSystemError = 1,
+    ShowApplicationError = 2,
+    ShowEula = 3,
+    ShowErrorPctl = 4,
+    ShowErrorRecord = 5,
+    ShowUpdateEula = 8,
+};
+
+class Error final : public Applet {
+public:
+    explicit Error(const Core::Frontend::ErrorApplet& frontend);
+    ~Error() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+
+    void DisplayCompleted();
+
+private:
+    union ErrorArguments;
+
+    const Core::Frontend::ErrorApplet& frontend;
+    ResultCode error_code = RESULT_SUCCESS;
+    ErrorAppletMode mode = ErrorAppletMode::ShowError;
+    std::unique_ptr<ErrorArguments> args;
+
+    bool complete = false;
+};
+
+} // namespace Service::AM::Applets

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

@@ -4,11 +4,15 @@
 
 #include <string>
 
+#include "common/assert.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
+#include "core/core.h"
+#include "core/frontend/applets/general_frontend.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/stub_applet.h"
+#include "core/hle/service/am/applets/general_backend.h"
 
 namespace Service::AM::Applets {
 
@@ -30,6 +34,55 @@ static void LogCurrentStorage(AppletDataBroker& broker, std::string prefix) {
     }
 }
 
+PhotoViewer::PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend) : frontend(frontend) {}
+
+PhotoViewer::~PhotoViewer() = default;
+
+void PhotoViewer::Initialize() {
+    Applet::Initialize();
+    complete = false;
+
+    const auto storage = broker.PopNormalDataToApplet();
+    ASSERT(storage != nullptr);
+    const auto data = storage->GetData();
+    ASSERT(!data.empty());
+    mode = static_cast<PhotoViewerAppletMode>(data[0]);
+}
+
+bool PhotoViewer::TransactionComplete() const {
+    return complete;
+}
+
+ResultCode PhotoViewer::GetStatus() const {
+    return RESULT_SUCCESS;
+}
+
+void PhotoViewer::ExecuteInteractive() {
+    UNREACHABLE_MSG("Unexpected interactive applet data.");
+}
+
+void PhotoViewer::Execute() {
+    if (complete)
+        return;
+
+    const auto callback = [this] { ViewFinished(); };
+    switch (mode) {
+    case PhotoViewerAppletMode::CurrentApp:
+        frontend.ShowPhotosForApplication(Core::CurrentProcess()->GetTitleID(), callback);
+        break;
+    case PhotoViewerAppletMode::AllApps:
+        frontend.ShowAllPhotos(callback);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", static_cast<u8>(mode));
+    }
+}
+
+void PhotoViewer::ViewFinished() {
+    broker.PushNormalDataFromApplet(IStorage{{}});
+    broker.SignalStateChanged();
+}
+
 StubApplet::StubApplet() = default;
 
 StubApplet::~StubApplet() = default;
@@ -67,4 +120,5 @@ void StubApplet::Execute() {
     broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
     broker.SignalStateChanged();
 }
+
 } // namespace Service::AM::Applets

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

@@ -0,0 +1,48 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Service::AM::Applets {
+
+enum class PhotoViewerAppletMode : u8 {
+    CurrentApp = 0,
+    AllApps = 1,
+};
+
+class PhotoViewer final : public Applet {
+public:
+    explicit PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend);
+    ~PhotoViewer() override;
+
+    void Initialize() override;
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+
+    void ViewFinished();
+
+private:
+    const Core::Frontend::PhotoViewerApplet& frontend;
+    bool complete = false;
+    PhotoViewerAppletMode mode = PhotoViewerAppletMode::CurrentApp;
+};
+
+class StubApplet final : public Applet {
+public:
+    StubApplet();
+    ~StubApplet() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+};
+
+} // namespace Service::AM::Applets

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

@@ -15,7 +15,9 @@ namespace Service::AM::Applets {
 
 constexpr ResultCode ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};
 
-ProfileSelect::ProfileSelect() = default;
+ProfileSelect::ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend)
+    : frontend(frontend) {}
+
 ProfileSelect::~ProfileSelect() = default;
 
 void ProfileSelect::Initialize() {
@@ -51,8 +53,6 @@ void ProfileSelect::Execute() {
         return;
     }
 
-    const auto& frontend{Core::System::GetInstance().GetProfileSelector()};
-
     frontend.SelectProfile([this](std::optional<Account::UUID> uuid) { SelectionComplete(uuid); });
 }
 

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

@@ -28,7 +28,7 @@ static_assert(sizeof(UserSelectionOutput) == 0x18, "UserSelectionOutput has inco
 
 class ProfileSelect final : public Applet {
 public:
-    ProfileSelect();
+    explicit ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend);
     ~ProfileSelect() override;
 
     void Initialize() override;
@@ -41,6 +41,8 @@ public:
     void SelectionComplete(std::optional<Account::UUID> uuid);
 
 private:
+    const Core::Frontend::ProfileSelectApplet& frontend;
+
     UserSelectionConfig config;
     bool complete = false;
     ResultCode status = RESULT_SUCCESS;

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

@@ -39,7 +39,8 @@ static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
     return params;
 }
 
-SoftwareKeyboard::SoftwareKeyboard() = default;
+SoftwareKeyboard::SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend)
+    : frontend(frontend) {}
 
 SoftwareKeyboard::~SoftwareKeyboard() = default;
 
@@ -90,8 +91,6 @@ void SoftwareKeyboard::ExecuteInteractive() {
     if (status == INTERACTIVE_STATUS_OK) {
         complete = true;
     } else {
-        const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
-
         std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
         std::memcpy(string.data(), data.data() + 4, string.size() * 2);
         frontend.SendTextCheckDialog(
@@ -106,8 +105,6 @@ void SoftwareKeyboard::Execute() {
         return;
     }
 
-    const auto& frontend{Core::System::GetInstance().GetSoftwareKeyboard()};
-
     const auto parameters = ConvertToFrontendParameters(config, initial_text);
 
     frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(text); },

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

@@ -55,7 +55,7 @@ static_assert(sizeof(KeyboardConfig) == 0x3E0, "KeyboardConfig has incorrect siz
 
 class SoftwareKeyboard final : public Applet {
 public:
-    SoftwareKeyboard();
+    explicit SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend);
     ~SoftwareKeyboard() override;
 
     void Initialize() override;
@@ -68,6 +68,8 @@ public:
     void WriteText(std::optional<std::u16string> text);
 
 private:
+    const Core::Frontend::SoftwareKeyboardApplet& frontend;
+
     KeyboardConfig config;
     std::u16string initial_text;
     bool complete = false;

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

@@ -1,24 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/am/applets/applets.h"
-
-namespace Service::AM::Applets {
-
-class StubApplet final : public Applet {
-public:
-    StubApplet();
-    ~StubApplet() override;
-
-    void Initialize() override;
-
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-};
-
-} // namespace Service::AM::Applets

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

@@ -86,7 +86,7 @@ static FileSys::VirtualFile GetManualRomFS() {
     if (loader.ReadManualRomFS(out) == Loader::ResultStatus::Success)
         return out;
 
-    const auto& installed{FileSystem::GetUnionContents()};
+    const auto& installed{Core::System::GetInstance().GetContentProvider()};
     const auto res = installed.GetEntry(Core::System::GetInstance().CurrentProcess()->GetTitleID(),
                                         FileSys::ContentRecordType::Manual);
 
@@ -95,7 +95,7 @@ static FileSys::VirtualFile GetManualRomFS() {
     return nullptr;
 }
 
-WebBrowser::WebBrowser() = default;
+WebBrowser::WebBrowser(Core::Frontend::WebBrowserApplet& frontend) : frontend(frontend) {}
 
 WebBrowser::~WebBrowser() = default;
 
@@ -152,8 +152,6 @@ void WebBrowser::Execute() {
         return;
     }
 
-    auto& frontend{Core::System::GetInstance().GetWebBrowser()};
-
     frontend.OpenPage(filename, [this] { UnpackRomFS(); }, [this] { Finalize(); });
 }
 

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

@@ -12,7 +12,7 @@ namespace Service::AM::Applets {
 
 class WebBrowser final : public Applet {
 public:
-    WebBrowser();
+    WebBrowser(Core::Frontend::WebBrowserApplet& frontend);
     ~WebBrowser() override;
 
     void Initialize() override;
@@ -32,6 +32,8 @@ public:
     void Finalize();
 
 private:
+    Core::Frontend::WebBrowserApplet& frontend;
+
     bool complete = false;
     bool unpacked = false;
     ResultCode status = RESULT_SUCCESS;

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

@@ -33,11 +33,11 @@ static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
 
 static std::vector<u64> AccumulateAOCTitleIDs() {
     std::vector<u64> add_on_content;
-    const auto rcu = FileSystem::GetUnionContents();
+    const auto& rcu = Core::System::GetInstance().GetContentProvider();
     const auto list =
         rcu.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
     std::transform(list.begin(), list.end(), std::back_inserter(add_on_content),
-                   [](const FileSys::RegisteredCacheEntry& rce) { return rce.title_id; });
+                   [](const FileSys::ContentProviderEntry& rce) { return rce.title_id; });
     add_on_content.erase(
         std::remove_if(
             add_on_content.begin(), add_on_content.end(),
@@ -50,6 +50,7 @@ static std::vector<u64> AccumulateAOCTitleIDs() {
 }
 
 AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs()) {
+    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CountAddOnContentByApplicationId"},
         {1, nullptr, "ListAddOnContentByApplicationId"},
@@ -60,7 +61,10 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
         {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
+        {100, nullptr, "CreateEcPurchasedEventManager"},
     };
+    // clang-format on
+
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();

src/core/hle/service/apm/interface.cpp

@@ -87,6 +87,8 @@ APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
         {3, nullptr, "GetLastThrottlingState"},
         {4, nullptr, "ClearLastThrottlingState"},
         {5, nullptr, "LoadAndApplySettings"},
+        {6, nullptr, "SetCpuBoostMode"},
+        {7, nullptr, "GetCurrentPerformanceConfiguration"},
     };
     // clang-format on
 

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

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/audio/audctl.h"
 
 namespace Service::Audio {
@@ -11,8 +13,8 @@ AudCtl::AudCtl() : ServiceFramework{"audctl"} {
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetTargetVolume"},
         {1, nullptr, "SetTargetVolume"},
-        {2, nullptr, "GetTargetVolumeMin"},
-        {3, nullptr, "GetTargetVolumeMax"},
+        {2, &AudCtl::GetTargetVolumeMin, "GetTargetVolumeMin"},
+        {3, &AudCtl::GetTargetVolumeMax, "GetTargetVolumeMax"},
         {4, nullptr, "IsTargetMute"},
         {5, nullptr, "SetTargetMute"},
         {6, nullptr, "IsTargetConnected"},
@@ -44,4 +46,28 @@ AudCtl::AudCtl() : ServiceFramework{"audctl"} {
 
 AudCtl::~AudCtl() = default;
 
+void AudCtl::GetTargetVolumeMin(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Audio, "called.");
+
+    // This service function is currently hardcoded on the
+    // actual console to this value (as of 6.0.0).
+    constexpr s32 target_min_volume = 0;
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(target_min_volume);
+}
+
+void AudCtl::GetTargetVolumeMax(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Audio, "called.");
+
+    // This service function is currently hardcoded on the
+    // actual console to this value (as of 6.0.0).
+    constexpr s32 target_max_volume = 15;
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(target_max_volume);
+}
+
 } // namespace Service::Audio

src/core/hle/service/audio/audctl.h

@@ -12,6 +12,10 @@ class AudCtl final : public ServiceFramework<AudCtl> {
 public:
     explicit AudCtl();
     ~AudCtl() override;
+
+private:
+    void GetTargetVolumeMin(Kernel::HLERequestContext& ctx);
+    void GetTargetVolumeMax(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Audio

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

@@ -25,6 +25,7 @@ public:
             {11, nullptr, "GetAudioInBufferCount"},
             {12, nullptr, "SetAudioInDeviceGain"},
             {13, nullptr, "GetAudioInDeviceGain"},
+            {14, nullptr, "FlushAudioInBuffers"},
         };
         // clang-format on
 

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

@@ -44,7 +44,7 @@ public:
               std::string&& unique_name)
         : ServiceFramework("IAudioOut"), audio_core(audio_core),
           device_name(std::move(device_name)), audio_params(audio_params) {
-
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
             {1, &IAudioOut::StartAudioOut, "StartAudioOut"},
@@ -58,7 +58,10 @@ public:
             {9, &IAudioOut::GetAudioOutBufferCount, "GetAudioOutBufferCount"},
             {10, nullptr, "GetAudioOutPlayedSampleCount"},
             {11, nullptr, "FlushAudioOutBuffers"},
+            {12, nullptr, "SetAudioOutVolume"},
+            {13, nullptr, "GetAudioOutVolume"},
         };
+        // clang-format on
         RegisterHandlers(functions);
 
         // This is the event handle used to check if the audio buffer was released

src/core/hle/service/btdrv/btdrv.cpp

@@ -154,7 +154,8 @@ public:
             {96, nullptr, "GetLeHidEventInfo"},
             {97, nullptr, "RegisterBleHidEvent"},
             {98, nullptr, "SetLeScanParameter"},
-            {256, nullptr, "GetIsManufacturingMode"}
+            {256, nullptr, "GetIsManufacturingMode"},
+            {257, nullptr, "EmulateBluetoothCrash"},
         };
         // clang-format on
 

src/core/hle/service/caps/caps.cpp

@@ -15,32 +15,41 @@ public:
     explicit CAPS_A() : ServiceFramework{"caps:a"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "Unknown5"},
-            {5, nullptr, "Unknown6"},
-            {6, nullptr, "Unknown7"},
-            {7, nullptr, "Unknown8"},
-            {8, nullptr, "Unknown9"},
-            {9, nullptr, "Unknown10"},
-            {10, nullptr, "Unknown11"},
-            {11, nullptr, "Unknown12"},
-            {12, nullptr, "Unknown13"},
-            {13, nullptr, "Unknown14"},
-            {14, nullptr, "Unknown15"},
-            {301, nullptr, "Unknown16"},
-            {401, nullptr, "Unknown17"},
-            {501, nullptr, "Unknown18"},
-            {1001, nullptr, "Unknown19"},
-            {1002, nullptr, "Unknown20"},
-            {8001, nullptr, "Unknown21"},
-            {8002, nullptr, "Unknown22"},
-            {8011, nullptr, "Unknown23"},
-            {8012, nullptr, "Unknown24"},
-            {8021, nullptr, "Unknown25"},
-            {10011, nullptr, "Unknown26"},
+            {0, nullptr, "GetAlbumFileCount"},
+            {1, nullptr, "GetAlbumFileList"},
+            {2, nullptr, "LoadAlbumFile"},
+            {3, nullptr, "DeleteAlbumFile"},
+            {4, nullptr, "StorageCopyAlbumFile"},
+            {5, nullptr, "IsAlbumMounted"},
+            {6, nullptr, "GetAlbumUsage"},
+            {7, nullptr, "GetAlbumFileSize"},
+            {8, nullptr, "LoadAlbumFileThumbnail"},
+            {9, nullptr, "LoadAlbumScreenShotImage"},
+            {10, nullptr, "LoadAlbumScreenShotThumbnailImage"},
+            {11, nullptr, "GetAlbumEntryFromApplicationAlbumEntry"},
+            {12, nullptr, "Unknown12"},
+            {13, nullptr, "Unknown13"},
+            {14, nullptr, "Unknown14"},
+            {15, nullptr, "Unknown15"},
+            {16, nullptr, "Unknown16"},
+            {17, nullptr, "Unknown17"},
+            {18, nullptr, "Unknown18"},
+            {202, nullptr, "SaveEditedScreenShot"},
+            {301, nullptr, "GetLastThumbnail"},
+            {401, nullptr, "GetAutoSavingStorage"},
+            {501, nullptr, "GetRequiredStorageSpaceSizeToCopyAll"},
+            {1001, nullptr, "Unknown1001"},
+            {1002, nullptr, "Unknown1002"},
+            {1003, nullptr, "Unknown1003"},
+            {8001, nullptr, "ForceAlbumUnmounted"},
+            {8002, nullptr, "ResetAlbumMountStatus"},
+            {8011, nullptr, "RefreshAlbumCache"},
+            {8012, nullptr, "GetAlbumCache"},
+            {8013, nullptr, "Unknown8013"},
+            {8021, nullptr, "GetAlbumEntryFromApplicationAlbumEntryAruid"},
+            {10011, nullptr, "SetInternalErrorConversionEnabled"},
+            {50000, nullptr, "Unknown50000"},
+            {60002, nullptr, "Unknown60002"},
         };
         // clang-format on
 
@@ -53,16 +62,17 @@ public:
     explicit CAPS_C() : ServiceFramework{"caps:c"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {2001, nullptr, "Unknown1"},
-            {2002, nullptr, "Unknown2"},
-            {2011, nullptr, "Unknown3"},
-            {2012, nullptr, "Unknown4"},
-            {2013, nullptr, "Unknown5"},
-            {2014, nullptr, "Unknown6"},
-            {2101, nullptr, "Unknown7"},
-            {2102, nullptr, "Unknown8"},
-            {2201, nullptr, "Unknown9"},
-            {2301, nullptr, "Unknown10"},
+            {33, nullptr, "Unknown33"},
+            {2001, nullptr, "Unknown2001"},
+            {2002, nullptr, "Unknown2002"},
+            {2011, nullptr, "Unknown2011"},
+            {2012, nullptr, "Unknown2012"},
+            {2013, nullptr, "Unknown2013"},
+            {2014, nullptr, "Unknown2014"},
+            {2101, nullptr, "Unknown2101"},
+            {2102, nullptr, "Unknown2102"},
+            {2201, nullptr, "Unknown2201"},
+            {2301, nullptr, "Unknown2301"},
         };
         // clang-format on
 
@@ -127,11 +137,18 @@ public:
     explicit CAPS_U() : ServiceFramework{"caps:u"} {
         // clang-format off
         static const FunctionInfo functions[] = {
+            {32, nullptr, "SetShimLibraryVersion"},
             {102, nullptr, "GetAlbumFileListByAruid"},
             {103, nullptr, "DeleteAlbumFileByAruid"},
             {104, nullptr, "GetAlbumFileSizeByAruid"},
+            {105, nullptr, "DeleteAlbumFileByAruidForDebug"},
             {110, nullptr, "LoadAlbumScreenShotImageByAruid"},
             {120, nullptr, "LoadAlbumScreenShotThumbnailImageByAruid"},
+            {130, nullptr, "PrecheckToCreateContentsByAruid"},
+            {140, nullptr, "GetAlbumFileList1AafeAruidDeprecated"},
+            {141, nullptr, "GetAlbumFileList2AafeUidAruidDeprecated"},
+            {142, nullptr, "GetAlbumFileList3AaeAruid"},
+            {143, nullptr, "GetAlbumFileList4AaeUidAruid"},
             {60002, nullptr, "OpenAccessorSessionForApplication"},
         };
         // clang-format on

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

@@ -391,11 +391,6 @@ void WriteSaveDataSize(FileSys::SaveDataType type, u64 title_id, u128 user_id,
         save_data_factory->WriteSaveDataSize(type, title_id, user_id, new_value);
 }
 
-FileSys::RegisteredCacheUnion GetUnionContents() {
-    return FileSys::RegisteredCacheUnion{
-        {GetSystemNANDContents(), GetUserNANDContents(), GetSDMCContents()}};
-}
-
 FileSys::RegisteredCache* GetSystemNANDContents() {
     LOG_TRACE(Service_FS, "Opening System NAND Contents");
 
@@ -460,6 +455,10 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
     if (bis_factory == nullptr) {
         bis_factory =
             std::make_unique<FileSys::BISFactory>(nand_directory, load_directory, dump_directory);
+        Core::System::GetInstance().RegisterContentProvider(
+            FileSys::ContentProviderUnionSlot::SysNAND, bis_factory->GetSystemNANDContents());
+        Core::System::GetInstance().RegisterContentProvider(
+            FileSys::ContentProviderUnionSlot::UserNAND, bis_factory->GetUserNANDContents());
     }
 
     if (save_data_factory == nullptr) {
@@ -468,6 +467,8 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
 
     if (sdmc_factory == nullptr) {
         sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
+        Core::System::GetInstance().RegisterContentProvider(FileSys::ContentProviderUnionSlot::SDMC,
+                                                            sdmc_factory->GetSDMCContents());
     }
 }
 

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

@@ -54,8 +54,6 @@ FileSys::SaveDataSize ReadSaveDataSize(FileSys::SaveDataType type, u64 title_id,
 void WriteSaveDataSize(FileSys::SaveDataType type, u64 title_id, u128 user_id,
                        FileSys::SaveDataSize new_value);
 
-FileSys::RegisteredCacheUnion GetUnionContents();
-
 FileSys::RegisteredCache* GetSystemNANDContents();
 FileSys::RegisteredCache* GetUserNANDContents();
 FileSys::RegisteredCache* GetSDMCContents();

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

@@ -115,11 +115,12 @@ private:
 
     void Read(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const u64 unk = rp.Pop<u64>();
+        const u64 option = rp.Pop<u64>();
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
+        LOG_DEBUG(Service_FS, "called, option={}, offset=0x{:X}, length={}", option, offset,
+                  length);
 
         // Error checking
         if (length < 0) {
@@ -148,11 +149,12 @@ private:
 
     void Write(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const u64 unk = rp.Pop<u64>();
+        const u64 option = rp.Pop<u64>();
         const s64 offset = rp.Pop<s64>();
         const s64 length = rp.Pop<s64>();
 
-        LOG_DEBUG(Service_FS, "called, offset=0x{:X}, length={}", offset, length);
+        LOG_DEBUG(Service_FS, "called, option={}, offset=0x{:X}, length={}", option, offset,
+                  length);
 
         // Error checking
         if (length < 0) {
@@ -250,10 +252,7 @@ private:
     u64 next_entry_index = 0;
 
     void Read(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 unk = rp.Pop<u64>();
-
-        LOG_DEBUG(Service_FS, "called, unk=0x{:X}", unk);
+        LOG_DEBUG(Service_FS, "called.");
 
         // Calculate how many entries we can fit in the output buffer
         const u64 count_entries = ctx.GetWriteBufferSize() / sizeof(FileSys::Entry);
@@ -665,10 +664,13 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {100, nullptr, "OpenImageDirectoryFileSystem"},
         {110, nullptr, "OpenContentStorageFileSystem"},
         {120, nullptr, "OpenCloudBackupWorkStorageFileSystem"},
+        {130, nullptr, "OpenCustomStorageFileSystem"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
         {201, nullptr, "OpenDataStorageByProgramId"},
         {202, &FSP_SRV::OpenDataStorageByDataId, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenPatchDataStorageByCurrentProcess, "OpenPatchDataStorageByCurrentProcess"},
+        {204, nullptr, "OpenDataFileSystemByProgramIndex"},
+        {205, nullptr, "OpenDataStorageByProgramIndex"},
         {400, nullptr, "OpenDeviceOperator"},
         {500, nullptr, "OpenSdCardDetectionEventNotifier"},
         {501, nullptr, "OpenGameCardDetectionEventNotifier"},
@@ -692,6 +694,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {614, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId"},
         {615, nullptr, "QuerySaveDataInternalStorageTotalSize"},
         {616, nullptr, "GetSaveDataCommitId"},
+        {617, nullptr, "UnregisterExternalKey"},
         {620, nullptr, "SetSdCardEncryptionSeed"},
         {630, nullptr, "SetSdCardAccessibility"},
         {631, nullptr, "IsSdCardAccessible"},
@@ -702,6 +705,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {710, nullptr, "ResolveAccessFailure"},
         {720, nullptr, "AbandonAccessFailure"},
         {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
+        {810, nullptr, "RegisterProgramIndexMapInfo"},
         {1000, nullptr, "SetBisRootForHost"},
         {1001, nullptr, "SetSaveDataSize"},
         {1002, nullptr, "SetSaveDataRootPath"},
@@ -712,6 +716,8 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {1007, nullptr, "RegisterUpdatePartition"},
         {1008, nullptr, "OpenRegisteredUpdatePartition"},
         {1009, nullptr, "GetAndClearMemoryReportInfo"},
+        {1010, nullptr, "SetDataStorageRedirectTarget"},
+        {1011, nullptr, "OutputAccessLogToSdCard2"},
         {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
         {1110, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId2"},
         {1200, nullptr, "OpenMultiCommitManager"},

src/core/hle/service/friend/friend.cpp

@@ -12,6 +12,7 @@ namespace Service::Friend {
 class IFriendService final : public ServiceFramework<IFriendService> {
 public:
     IFriendService() : ServiceFramework("IFriendService") {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "GetCompletionEvent"},
             {1, nullptr, "Cancel"},
@@ -24,8 +25,7 @@ public:
             {10400, nullptr, "GetBlockedUserListIds"},
             {10500, nullptr, "GetProfileList"},
             {10600, nullptr, "DeclareOpenOnlinePlaySession"},
-            {10601, &IFriendService::DeclareCloseOnlinePlaySession,
-             "DeclareCloseOnlinePlaySession"},
+            {10601, &IFriendService::DeclareCloseOnlinePlaySession, "DeclareCloseOnlinePlaySession"},
             {10610, &IFriendService::UpdateUserPresence, "UpdateUserPresence"},
             {10700, nullptr, "GetPlayHistoryRegistrationKey"},
             {10701, nullptr, "GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId"},
@@ -88,6 +88,7 @@ public:
             {30830, nullptr, "ClearPlayLog"},
             {49900, nullptr, "DeleteNetworkServiceAccountCache"},
         };
+        // clang-format on
 
         RegisterHandlers(functions);
     }

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

@@ -210,6 +210,7 @@ Hid::Hid() : ServiceFramework("hid") {
         {131, nullptr, "IsUnintendedHomeButtonInputProtectionEnabled"},
         {132, nullptr, "EnableUnintendedHomeButtonInputProtection"},
         {133, nullptr, "SetNpadJoyAssignmentModeSingleWithDestination"},
+        {134, nullptr, "SetNpadAnalogStickUseCenterClamp"},
         {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
         {201, &Hid::SendVibrationValue, "SendVibrationValue"},
         {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
@@ -221,6 +222,7 @@ Hid::Hid() : ServiceFramework("hid") {
         {208, nullptr, "GetActualVibrationGcErmCommand"},
         {209, &Hid::BeginPermitVibrationSession, "BeginPermitVibrationSession"},
         {210, &Hid::EndPermitVibrationSession, "EndPermitVibrationSession"},
+        {211, nullptr, "IsVibrationDeviceMounted"},
         {300, &Hid::ActivateConsoleSixAxisSensor, "ActivateConsoleSixAxisSensor"},
         {301, &Hid::StartConsoleSixAxisSensor, "StartConsoleSixAxisSensor"},
         {302, nullptr, "StopConsoleSixAxisSensor"},
@@ -265,6 +267,7 @@ Hid::Hid() : ServiceFramework("hid") {
         {523, nullptr, "SetIsPalmaPairedConnectable"},
         {524, nullptr, "PairPalma"},
         {525, &Hid::SetPalmaBoostMode, "SetPalmaBoostMode"},
+        {526, nullptr, "CancelWritePalmaWaveEntry"},
         {1000, nullptr, "SetNpadCommunicationMode"},
         {1001, nullptr, "GetNpadCommunicationMode"},
     };
@@ -797,12 +800,22 @@ public:
             {232, nullptr, "EnableShipmentMode"},
             {233, nullptr, "ClearPairingInfo"},
             {234, nullptr, "GetUniquePadDeviceTypeSetInternal"},
+            {235, nullptr, "EnableAnalogStickPower"},
             {301, nullptr, "GetAbstractedPadHandles"},
             {302, nullptr, "GetAbstractedPadState"},
             {303, nullptr, "GetAbstractedPadsState"},
             {321, nullptr, "SetAutoPilotVirtualPadState"},
             {322, nullptr, "UnsetAutoPilotVirtualPadState"},
             {323, nullptr, "UnsetAllAutoPilotVirtualPadState"},
+            {324, nullptr, "AttachHdlsWorkBuffer"},
+            {325, nullptr, "ReleaseHdlsWorkBuffer"},
+            {326, nullptr, "DumpHdlsNpadAssignmentState"},
+            {327, nullptr, "DumpHdlsStates"},
+            {328, nullptr, "ApplyHdlsNpadAssignmentState"},
+            {329, nullptr, "ApplyHdlsStateList"},
+            {330, nullptr, "AttachHdlsVirtualDevice"},
+            {331, nullptr, "DetachHdlsVirtualDevice"},
+            {332, nullptr, "SetHdlsState"},
             {350, nullptr, "AddRegisteredDevice"},
             {400, nullptr, "DisableExternalMcuOnNxDevice"},
             {401, nullptr, "DisableRailDeviceFiltering"},
@@ -825,6 +838,7 @@ public:
             {131, nullptr, "ActivateSleepButton"},
             {141, nullptr, "AcquireCaptureButtonEventHandle"},
             {151, nullptr, "ActivateCaptureButton"},
+            {161, nullptr, "GetPlatformConfig"},
             {210, nullptr, "AcquireNfcDeviceUpdateEventHandle"},
             {211, nullptr, "GetNpadsWithNfc"},
             {212, nullptr, "AcquireNfcActivateEventHandle"},
@@ -894,6 +908,7 @@ public:
             {827, nullptr, "IsAnalogStickButtonPressed"},
             {828, nullptr, "IsAnalogStickInReleasePosition"},
             {829, nullptr, "IsAnalogStickInCircumference"},
+            {830, nullptr, "SetNotificationLedPattern"},
             {850, nullptr, "IsUsbFullKeyControllerEnabled"},
             {851, nullptr, "EnableUsbFullKeyController"},
             {852, nullptr, "IsUsbConnected"},

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

@@ -52,9 +52,11 @@ public:
     }
 };
 
-class ILocalCommunicationService final : public ServiceFramework<ILocalCommunicationService> {
+class ISystemLocalCommunicationService final
+    : public ServiceFramework<ISystemLocalCommunicationService> {
 public:
-    explicit ILocalCommunicationService(const char* name) : ServiceFramework{name} {
+    explicit ISystemLocalCommunicationService()
+        : ServiceFramework{"ISystemLocalCommunicationService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "GetState"},
@@ -84,6 +86,50 @@ public:
             {304, nullptr, "Disconnect"},
             {400, nullptr, "InitializeSystem"},
             {401, nullptr, "FinalizeSystem"},
+            {402, nullptr, "SetOperationMode"},
+            {403, nullptr, "InitializeSystem2"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class IUserLocalCommunicationService final
+    : public ServiceFramework<IUserLocalCommunicationService> {
+public:
+    explicit IUserLocalCommunicationService() : ServiceFramework{"IUserLocalCommunicationService"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetState"},
+            {1, nullptr, "GetNetworkInfo"},
+            {2, nullptr, "GetIpv4Address"},
+            {3, nullptr, "GetDisconnectReason"},
+            {4, nullptr, "GetSecurityParameter"},
+            {5, nullptr, "GetNetworkConfig"},
+            {100, nullptr, "AttachStateChangeEvent"},
+            {101, nullptr, "GetNetworkInfoLatestUpdate"},
+            {102, nullptr, "Scan"},
+            {103, nullptr, "ScanPrivate"},
+            {104, nullptr, "SetWirelessControllerRestriction"},
+            {200, nullptr, "OpenAccessPoint"},
+            {201, nullptr, "CloseAccessPoint"},
+            {202, nullptr, "CreateNetwork"},
+            {203, nullptr, "CreateNetworkPrivate"},
+            {204, nullptr, "DestroyNetwork"},
+            {205, nullptr, "Reject"},
+            {206, nullptr, "SetAdvertiseData"},
+            {207, nullptr, "SetStationAcceptPolicy"},
+            {208, nullptr, "AddAcceptFilterEntry"},
+            {209, nullptr, "ClearAcceptFilter"},
+            {300, nullptr, "OpenStation"},
+            {301, nullptr, "CloseStation"},
+            {302, nullptr, "Connect"},
+            {303, nullptr, "ConnectPrivate"},
+            {304, nullptr, "Disconnect"},
+            {400, nullptr, "Initialize"},
+            {401, nullptr, "Finalize"},
+            {402, nullptr, "SetOperationMode"},
         };
         // clang-format on
 
@@ -108,7 +154,7 @@ public:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILocalCommunicationService>("ISystemLocalCommunicationService");
+        rb.PushIpcInterface<ISystemLocalCommunicationService>();
     }
 };
 
@@ -129,7 +175,7 @@ public:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILocalCommunicationService>("IUserLocalCommunicationService");
+        rb.PushIpcInterface<IUserLocalCommunicationService>();
     }
 };