core/file_sys: Replace includes with forward declarations where applicable

Avoids proliferating includes through other headers, lessening the total
amount of files that need to be rebuilt if those headers are changed.
This also resolves a few indirect inclusions.

.travis.yml

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

.travis/common/travis-ci.env

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

.travis/linux/build.sh

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

.travis/linux/docker.sh

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

.travis/macos/build.sh

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

CMakeLists.txt

@@ -41,19 +41,6 @@ function(check_submodules_present)
 endfunction()
 check_submodules_present()
 
-configure_file(${CMAKE_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
-               ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
-               COPYONLY)
-if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    message(STATUS "Downloading compatibility list for yuzu...")
-    file(DOWNLOAD
-        https://api.yuzu-emu.org/gamedb/
-        "${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
-endif()
-if (NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    file(WRITE ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
-endif()
-
 # Detect current compilation architecture and create standard definitions
 # =======================================================================
 

appveyor.yml

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

dist/compatibility_list/compatibility_list.qrc

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

src/audio_core/algorithm/filter.cpp

@@ -46,7 +46,7 @@ void Filter::Process(std::vector<s16>& signal) {
             out[0][ch] = b0 * in[0][ch] + b1 * in[1][ch] + b2 * in[2][ch] - a1 * out[1][ch] -
                          a2 * out[2][ch];
 
-            signal[i * 2 + ch] = static_cast<s16>(std::clamp(out[0][ch], -32768.0, 32767.0));
+            signal[i * 2 + ch] = std::clamp(out[0][ch], -32768.0, 32767.0);
         }
     }
 }

src/common/bit_field.h

@@ -178,7 +178,8 @@ public:
         return ExtractValue(storage);
     }
 
-    constexpr explicit operator bool() const {
+    // TODO: we may want to change this to explicit operator bool() if it's bug-free in VS2015
+    constexpr FORCE_INLINE bool ToBool() const {
         return Value() != 0;
     }
 

src/common/file_util.cpp

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

src/common/hex_util.cpp

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

src/common/hex_util.h

@@ -10,8 +10,6 @@
 #include <fmt/format.h>
 #include "common/common_types.h"
 
-namespace Common {
-
 u8 ToHexNibble(char c1);
 
 template <size_t Size, bool le = false>
@@ -37,5 +35,3 @@ std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
 
 std::array<u8, 0x10> operator"" _array16(const char* str, size_t len);
 std::array<u8, 0x20> operator"" _array32(const char* str, size_t len);
-
-} // namespace Common

src/common/logging/text_formatter.cpp

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

src/common/telemetry.cpp

@@ -3,15 +3,8 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cstring>
-#include "common/assert.h"
-#include "common/scm_rev.h"
 #include "common/telemetry.h"
 
-#ifdef ARCHITECTURE_x86_64
-#include "common/x64/cpu_detect.h"
-#endif
-
 namespace Telemetry {
 
 void FieldCollection::Accept(VisitorInterface& visitor) const {
@@ -44,62 +37,4 @@ template class Field<std::string>;
 template class Field<const char*>;
 template class Field<std::chrono::microseconds>;
 
-#ifdef ARCHITECTURE_x86_64
-static const char* CpuVendorToStr(Common::CPUVendor vendor) {
-    switch (vendor) {
-    case Common::CPUVendor::INTEL:
-        return "Intel";
-    case Common::CPUVendor::AMD:
-        return "Amd";
-    case Common::CPUVendor::OTHER:
-        return "Other";
-    }
-    UNREACHABLE();
-}
-#endif
-
-void AppendBuildInfo(FieldCollection& fc) {
-    const bool is_git_dirty{std::strstr(Common::g_scm_desc, "dirty") != nullptr};
-    fc.AddField(FieldType::App, "Git_IsDirty", is_git_dirty);
-    fc.AddField(FieldType::App, "Git_Branch", Common::g_scm_branch);
-    fc.AddField(FieldType::App, "Git_Revision", Common::g_scm_rev);
-    fc.AddField(FieldType::App, "BuildDate", Common::g_build_date);
-    fc.AddField(FieldType::App, "BuildName", Common::g_build_name);
-}
-
-void AppendCPUInfo(FieldCollection& fc) {
-#ifdef ARCHITECTURE_x86_64
-    fc.AddField(FieldType::UserSystem, "CPU_Model", Common::GetCPUCaps().cpu_string);
-    fc.AddField(FieldType::UserSystem, "CPU_BrandString", Common::GetCPUCaps().brand_string);
-    fc.AddField(FieldType::UserSystem, "CPU_Vendor", CpuVendorToStr(Common::GetCPUCaps().vendor));
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AES", Common::GetCPUCaps().aes);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX", Common::GetCPUCaps().avx);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX2", Common::GetCPUCaps().avx2);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI1", Common::GetCPUCaps().bmi1);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI2", Common::GetCPUCaps().bmi2);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_FMA", Common::GetCPUCaps().fma);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_FMA4", Common::GetCPUCaps().fma4);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE", Common::GetCPUCaps().sse);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE2", Common::GetCPUCaps().sse2);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE3", Common::GetCPUCaps().sse3);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSSE3", Common::GetCPUCaps().ssse3);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE41", Common::GetCPUCaps().sse4_1);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE42", Common::GetCPUCaps().sse4_2);
-#else
-    fc.AddField(FieldType::UserSystem, "CPU_Model", "Other");
-#endif
-}
-
-void AppendOSInfo(FieldCollection& fc) {
-#ifdef __APPLE__
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Apple");
-#elif defined(_WIN32)
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Windows");
-#elif defined(__linux__) || defined(linux) || defined(__linux)
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Linux");
-#else
-    fc.AddField(FieldType::UserSystem, "OsPlatform", "Unknown");
-#endif
-}
-
 } // namespace Telemetry

src/common/telemetry.h

@@ -180,16 +180,4 @@ struct NullVisitor : public VisitorInterface {
     void Complete() override {}
 };
 
-/// Appends build-specific information to the given FieldCollection,
-/// such as branch name, revision hash, etc.
-void AppendBuildInfo(FieldCollection& fc);
-
-/// Appends CPU-specific information to the given FieldCollection,
-/// such as instruction set extensions, etc.
-void AppendCPUInfo(FieldCollection& fc);
-
-/// Appends OS-specific information to the given FieldCollection,
-/// such as platform name, etc.
-void AppendOSInfo(FieldCollection& fc);
-
 } // namespace Telemetry

src/core/CMakeLists.txt

@@ -20,8 +20,6 @@ add_library(core STATIC
     crypto/key_manager.h
     crypto/ctr_encryption_layer.cpp
     crypto/ctr_encryption_layer.h
-    crypto/xts_encryption_layer.cpp
-    crypto/xts_encryption_layer.h
     file_sys/bis_factory.cpp
     file_sys/bis_factory.h
     file_sys/card_image.cpp
@@ -59,8 +57,6 @@ add_library(core STATIC
     file_sys/vfs_real.h
     file_sys/vfs_vector.cpp
     file_sys/vfs_vector.h
-    file_sys/xts_archive.cpp
-    file_sys/xts_archive.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
@@ -126,8 +122,6 @@ add_library(core STATIC
     hle/service/acc/acc_u0.h
     hle/service/acc/acc_u1.cpp
     hle/service/acc/acc_u1.h
-    hle/service/acc/profile_manager.cpp
-    hle/service/acc/profile_manager.h
     hle/service/am/am.cpp
     hle/service/am/am.h
     hle/service/am/applet_ae.cpp
@@ -351,8 +345,6 @@ add_library(core STATIC
     loader/linker.h
     loader/loader.cpp
     loader/loader.h
-    loader/nax.cpp
-    loader/nax.h
     loader/nca.cpp
     loader/nca.h
     loader/nro.cpp

src/core/arm/arm_interface.h

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

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -9,14 +9,11 @@
 #include "common/logging/log.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 
-namespace Core {
-
 using Vector = Dynarmic::A64::Vector;
 
 class ARM_Dynarmic_Callbacks : public Dynarmic::A64::UserCallbacks {
@@ -137,9 +134,6 @@ std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
     config.dczid_el0 = 4;
     config.ctr_el0 = 0x8444c004;
 
-    // Unpredictable instructions
-    config.define_unpredictable_behaviour = true;
-
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 
@@ -303,5 +297,3 @@ bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, VAddr vaddr,
         Memory::Write64(vaddr, value[1]);
     });
 }
-
-} // namespace Core

src/core/arm/dynarmic/arm_dynarmic.h

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

src/core/arm/exclusive_monitor.cpp

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

src/core/arm/exclusive_monitor.h

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

src/core/arm/unicorn/arm_unicorn.cpp

@@ -11,8 +11,6 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/svc.h"
 
-namespace Core {
-
 // Load Unicorn DLL once on Windows using RAII
 #ifdef _MSC_VER
 #include <unicorn_dynload.h>
@@ -213,7 +211,7 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
     }
 }
 
-void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
+void ARM_Unicorn::SaveContext(ARM_Interface::ThreadContext& ctx) {
     int uregs[32];
     void* tregs[32];
 
@@ -240,7 +238,7 @@ void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
     CHECKED(uc_reg_read_batch(uc, uregs, tregs, 32));
 }
 
-void ARM_Unicorn::LoadContext(const ThreadContext& ctx) {
+void ARM_Unicorn::LoadContext(const ARM_Interface::ThreadContext& ctx) {
     int uregs[32];
     void* tregs[32];
 
@@ -279,5 +277,3 @@ void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
     last_bkpt = bkpt;
     last_bkpt_hit = true;
 }
-
-} // namespace Core

src/core/arm/unicorn/arm_unicorn.h

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

src/core/core.cpp

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

src/core/core.h

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

src/core/core_cpu.h

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

src/core/crypto/aes_util.cpp

@@ -99,7 +99,10 @@ void AESCipher<Key, KeySize>::Transcode(const u8* src, size_t size, u8* dest, Op
 template <typename Key, size_t KeySize>
 void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, size_t size, u8* dest, size_t sector_id,
                                            size_t sector_size, Op op) {
-    ASSERT_MSG(size % sector_size == 0, "XTS decryption size must be a multiple of sector size.");
+    if (size % sector_size > 0) {
+        LOG_CRITICAL(Crypto, "Data size must be a multiple of sector size.");
+        return;
+    }
 
     for (size_t i = 0; i < size; i += sector_size) {
         SetIV(CalculateNintendoTweak(sector_id++));
@@ -109,4 +112,4 @@ void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, size_t size, u8* dest,
 
 template class AESCipher<Key128>;
 template class AESCipher<Key256>;
-} // namespace Core::Crypto
+} // namespace Core::Crypto

src/core/crypto/ctr_encryption_layer.cpp

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

src/core/crypto/key_manager.cpp

@@ -12,112 +12,11 @@
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
 #include "core/settings.h"
 
 namespace Core::Crypto {
 
-Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed) {
-    Key128 out{};
-
-    AESCipher<Key128> cipher1(master, Mode::ECB);
-    cipher1.Transcode(kek_seed.data(), kek_seed.size(), out.data(), Op::Decrypt);
-    AESCipher<Key128> cipher2(out, Mode::ECB);
-    cipher2.Transcode(source.data(), source.size(), out.data(), Op::Decrypt);
-
-    if (key_seed != Key128{}) {
-        AESCipher<Key128> cipher3(out, Mode::ECB);
-        cipher3.Transcode(key_seed.data(), key_seed.size(), out.data(), Op::Decrypt);
-    }
-
-    return out;
-}
-
-boost::optional<Key128> DeriveSDSeed() {
-    const FileUtil::IOFile save_43(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                                       "/system/save/8000000000000043",
-                                   "rb+");
-    if (!save_43.IsOpen())
-        return boost::none;
-    const FileUtil::IOFile sd_private(
-        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir) + "/Nintendo/Contents/private", "rb+");
-    if (!sd_private.IsOpen())
-        return boost::none;
-
-    sd_private.Seek(0, SEEK_SET);
-    std::array<u8, 0x10> private_seed{};
-    if (sd_private.ReadBytes(private_seed.data(), private_seed.size()) != 0x10)
-        return boost::none;
-
-    std::array<u8, 0x10> buffer{};
-    size_t offset = 0;
-    for (; offset + 0x10 < save_43.GetSize(); ++offset) {
-        save_43.Seek(offset, SEEK_SET);
-        save_43.ReadBytes(buffer.data(), buffer.size());
-        if (buffer == private_seed)
-            break;
-    }
-
-    if (offset + 0x10 >= save_43.GetSize())
-        return boost::none;
-
-    Key128 seed{};
-    save_43.Seek(offset + 0x10, SEEK_SET);
-    save_43.ReadBytes(seed.data(), seed.size());
-    return seed;
-}
-
-Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, const KeyManager& keys) {
-    if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKEK)))
-        return Loader::ResultStatus::ErrorMissingSDKEKSource;
-    if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKEKGeneration)))
-        return Loader::ResultStatus::ErrorMissingAESKEKGenerationSource;
-    if (!keys.HasKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration)))
-        return Loader::ResultStatus::ErrorMissingAESKeyGenerationSource;
-
-    const auto sd_kek_source =
-        keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKEK));
-    const auto aes_kek_gen =
-        keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKEKGeneration));
-    const auto aes_key_gen =
-        keys.GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration));
-    const auto master_00 = keys.GetKey(S128KeyType::Master);
-    const auto sd_kek =
-        GenerateKeyEncryptionKey(sd_kek_source, master_00, aes_kek_gen, aes_key_gen);
-
-    if (!keys.HasKey(S128KeyType::SDSeed))
-        return Loader::ResultStatus::ErrorMissingSDSeed;
-    const auto sd_seed = keys.GetKey(S128KeyType::SDSeed);
-
-    if (!keys.HasKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::Save)))
-        return Loader::ResultStatus::ErrorMissingSDSaveKeySource;
-    if (!keys.HasKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::NCA)))
-        return Loader::ResultStatus::ErrorMissingSDNCAKeySource;
-
-    std::array<Key256, 2> sd_key_sources{
-        keys.GetKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::Save)),
-        keys.GetKey(S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::NCA)),
-    };
-
-    // Combine sources and seed
-    for (auto& source : sd_key_sources) {
-        for (size_t i = 0; i < source.size(); ++i)
-            source[i] ^= sd_seed[i & 0xF];
-    }
-
-    AESCipher<Key128> cipher(sd_kek, Mode::ECB);
-    // The transform manipulates sd_keys as part of the Transcode, so the return/output is
-    // unnecessary. This does not alter sd_keys_sources.
-    std::transform(sd_key_sources.begin(), sd_key_sources.end(), sd_keys.begin(),
-                   sd_key_sources.begin(), [&cipher](const Key256& source, Key256& out) {
-                       cipher.Transcode(source.data(), source.size(), out.data(), Op::Decrypt);
-                       return source; ///< Return unaltered source to satisfy output requirement.
-                   });
-
-    return Loader::ResultStatus::Success;
-}
-
 KeyManager::KeyManager() {
     // Initialize keys
     const std::string hactool_keys_dir = FileUtil::GetHactoolConfigurationPath();
@@ -125,15 +24,12 @@ KeyManager::KeyManager() {
     if (Settings::values.use_dev_keys) {
         dev_mode = true;
         AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "dev.keys", false);
-        AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "dev.keys_autogenerated", false);
     } else {
         dev_mode = false;
         AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "prod.keys", false);
-        AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "prod.keys_autogenerated", false);
     }
 
     AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "title.keys", true);
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "title.keys_autogenerated", true);
 }
 
 void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
@@ -156,21 +52,21 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
         out[1].erase(std::remove(out[1].begin(), out[1].end(), ' '), out[1].end());
 
         if (is_title_keys) {
-            auto rights_id_raw = Common::HexStringToArray<16>(out[0]);
+            auto rights_id_raw = HexStringToArray<16>(out[0]);
             u128 rights_id{};
             std::memcpy(rights_id.data(), rights_id_raw.data(), rights_id_raw.size());
-            Key128 key = Common::HexStringToArray<16>(out[1]);
-            s128_keys[{S128KeyType::Titlekey, rights_id[1], rights_id[0]}] = key;
+            Key128 key = HexStringToArray<16>(out[1]);
+            SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
         } else {
             std::transform(out[0].begin(), out[0].end(), out[0].begin(), ::tolower);
             if (s128_file_id.find(out[0]) != s128_file_id.end()) {
                 const auto index = s128_file_id.at(out[0]);
-                Key128 key = Common::HexStringToArray<16>(out[1]);
-                s128_keys[{index.type, index.field1, index.field2}] = key;
+                Key128 key = HexStringToArray<16>(out[1]);
+                SetKey(index.type, key, index.field1, index.field2);
             } else if (s256_file_id.find(out[0]) != s256_file_id.end()) {
                 const auto index = s256_file_id.at(out[0]);
-                Key256 key = Common::HexStringToArray<32>(out[1]);
-                s256_keys[{index.type, index.field1, index.field2}] = key;
+                Key256 key = HexStringToArray<32>(out[1]);
+                SetKey(index.type, key, index.field1, index.field2);
             }
         }
     }
@@ -204,50 +100,11 @@ Key256 KeyManager::GetKey(S256KeyType id, u64 field1, u64 field2) const {
     return s256_keys.at({id, field1, field2});
 }
 
-template <size_t Size>
-void KeyManager::WriteKeyToFile(bool title_key, std::string_view keyname,
-                                const std::array<u8, Size>& key) {
-    const std::string yuzu_keys_dir = FileUtil::GetUserPath(FileUtil::UserPath::KeysDir);
-    std::string filename = "title.keys_autogenerated";
-    if (!title_key)
-        filename = dev_mode ? "dev.keys_autogenerated" : "prod.keys_autogenerated";
-    const auto add_info_text = !FileUtil::Exists(yuzu_keys_dir + DIR_SEP + filename);
-    FileUtil::CreateFullPath(yuzu_keys_dir + DIR_SEP + filename);
-    std::ofstream file(yuzu_keys_dir + DIR_SEP + filename, std::ios::app);
-    if (!file.is_open())
-        return;
-    if (add_info_text) {
-        file
-            << "# This file is autogenerated by Yuzu\n"
-            << "# It serves to store keys that were automatically generated from the normal keys\n"
-            << "# If you are experiencing issues involving keys, it may help to delete this file\n";
-    }
-
-    file << fmt::format("\n{} = {}", keyname, Common::HexArrayToString(key));
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, filename, title_key);
-}
-
 void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
-    const auto iter = std::find_if(
-        s128_file_id.begin(), s128_file_id.end(),
-        [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S128KeyType>> elem) {
-            return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
-                   std::tie(id, field1, field2);
-        });
-    if (iter != s128_file_id.end())
-        WriteKeyToFile(id == S128KeyType::Titlekey, iter->first, key);
     s128_keys[{id, field1, field2}] = key;
 }
 
 void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
-    const auto iter = std::find_if(
-        s256_file_id.begin(), s256_file_id.end(),
-        [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S256KeyType>> elem) {
-            return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
-                   std::tie(id, field1, field2);
-        });
-    if (iter != s256_file_id.end())
-        WriteKeyToFile(false, iter->first, key);
     s256_keys[{id, field1, field2}] = key;
 }
 
@@ -268,16 +125,7 @@ bool KeyManager::KeyFileExists(bool title) {
            FileUtil::Exists(yuzu_keys_dir + DIR_SEP + "prod.keys");
 }
 
-void KeyManager::DeriveSDSeedLazy() {
-    if (HasKey(S128KeyType::SDSeed))
-        return;
-
-    const auto res = DeriveSDSeed();
-    if (res != boost::none)
-        SetKey(S128KeyType::SDSeed, res.get());
-}
-
-const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager::s128_file_id = {
+const std::unordered_map<std::string, KeyIndex<S128KeyType>> KeyManager::s128_file_id = {
     {"master_key_00", {S128KeyType::Master, 0, 0}},
     {"master_key_01", {S128KeyType::Master, 1, 0}},
     {"master_key_02", {S128KeyType::Master, 2, 0}},
@@ -319,17 +167,11 @@ const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager:
     {"key_area_key_system_02", {S128KeyType::KeyArea, 2, static_cast<u64>(KeyAreaKeyType::System)}},
     {"key_area_key_system_03", {S128KeyType::KeyArea, 3, static_cast<u64>(KeyAreaKeyType::System)}},
     {"key_area_key_system_04", {S128KeyType::KeyArea, 4, static_cast<u64>(KeyAreaKeyType::System)}},
-    {"sd_card_kek_source", {S128KeyType::Source, static_cast<u64>(SourceKeyType::SDKEK), 0}},
-    {"aes_kek_generation_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKEKGeneration), 0}},
-    {"aes_key_generation_source",
-     {S128KeyType::Source, static_cast<u64>(SourceKeyType::AESKeyGeneration), 0}},
-    {"sd_seed", {S128KeyType::SDSeed, 0, 0}},
 };
 
-const boost::container::flat_map<std::string, KeyIndex<S256KeyType>> KeyManager::s256_file_id = {
+const std::unordered_map<std::string, KeyIndex<S256KeyType>> KeyManager::s256_file_id = {
     {"header_key", {S256KeyType::Header, 0, 0}},
-    {"sd_card_save_key_source", {S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::Save), 0}},
-    {"sd_card_nca_key_source", {S256KeyType::SDKeySource, static_cast<u64>(SDKeyType::NCA), 0}},
+    {"sd_card_save_key", {S256KeyType::SDSave, 0, 0}},
+    {"sd_card_nca_key", {S256KeyType::SDNCA, 0, 0}},
 };
 } // namespace Core::Crypto

src/core/crypto/key_manager.h

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

src/core/crypto/xts_encryption_layer.cpp

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

src/core/crypto/xts_encryption_layer.h

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

src/core/file_sys/bis_factory.cpp

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

src/core/file_sys/bis_factory.h

@@ -5,11 +5,12 @@
 #pragma once
 
 #include <memory>
-#include "core/loader/loader.h"
-#include "registered_cache.h"
+#include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
+class RegisteredCache;
+
 /// File system interface to the Built-In Storage
 /// This is currently missing accessors to BIS partitions, but seemed like a good place for the NAND
 /// registered caches.

src/core/file_sys/card_image.cpp

@@ -43,8 +43,6 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
             partitions[static_cast<size_t>(partition)] = std::make_shared<PartitionFilesystem>(raw);
     }
 
-    program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
-
     auto result = AddNCAFromPartition(XCIPartition::Secure);
     if (result != Loader::ResultStatus::Success) {
         status = result;
@@ -78,10 +76,6 @@ Loader::ResultStatus XCI::GetStatus() const {
     return status;
 }
 
-Loader::ResultStatus XCI::GetProgramNCAStatus() const {
-    return program_nca_status;
-}
-
 VirtualDir XCI::GetPartition(XCIPartition partition) const {
     return partitions[static_cast<size_t>(partition)];
 }
@@ -149,12 +143,6 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
         if (file->GetExtension() != "nca")
             continue;
         auto nca = std::make_shared<NCA>(file);
-        // TODO(DarkLordZach): Add proper Rev1+ Support
-        if (nca->IsUpdate())
-            continue;
-        if (nca->GetType() == NCAContentType::Program) {
-            program_nca_status = nca->GetStatus();
-        }
         if (nca->GetStatus() == Loader::ResultStatus::Success) {
             ncas.push_back(std::move(nca));
         } else {

src/core/file_sys/card_image.h

@@ -59,7 +59,6 @@ public:
     explicit XCI(VirtualFile file);
 
     Loader::ResultStatus GetStatus() const;
-    Loader::ResultStatus GetProgramNCAStatus() const;
 
     u8 GetFormatVersion() const;
 
@@ -91,7 +90,6 @@ private:
     GamecardHeader header{};
 
     Loader::ResultStatus status;
-    Loader::ResultStatus program_nca_status;
 
     std::vector<VirtualDir> partitions;
     std::vector<std::shared_ptr<NCA>> ncas;

src/core/file_sys/content_archive.cpp

@@ -9,6 +9,7 @@
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
 #include "core/file_sys/content_archive.h"
+#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
@@ -178,7 +179,7 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
             return std::static_pointer_cast<VfsFile>(out);
         }
     case NCASectionCryptoType::XTS:
-        // TODO(DarkLordZach): Find a test case for XTS-encrypted NCAs
+        // TODO(DarkLordZach): Implement XTSEncryptionLayer.
     default:
         LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
                   static_cast<u8>(s_header.raw.header.crypto_type));
@@ -258,10 +259,6 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
         file->ReadBytes(sections.data(), length_sections, SECTION_HEADER_OFFSET);
     }
 
-    is_update = std::find_if(sections.begin(), sections.end(), [](const NCASectionHeader& header) {
-                    return header.raw.header.crypto_type == NCASectionCryptoType::BKTR;
-                }) != sections.end();
-
     for (std::ptrdiff_t i = 0; i < number_sections; ++i) {
         auto section = sections[i];
 
@@ -362,10 +359,6 @@ VirtualFile NCA::GetBaseFile() const {
     return file;
 }
 
-bool NCA::IsUpdate() const {
-    return is_update;
-}
-
 bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
     return false;
 }

src/core/file_sys/content_archive.h

@@ -14,7 +14,6 @@
 #include "common/swap.h"
 #include "control_metadata.h"
 #include "core/crypto/key_manager.h"
-#include "core/file_sys/partition_filesystem.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
@@ -27,7 +26,6 @@ enum class NCAContentType : u8 {
     Control = 2,
     Manual = 3,
     Data = 4,
-    Data_Unknown5 = 5, ///< Seems to be used on some system archives
 };
 
 enum class NCASectionCryptoType : u8 {
@@ -93,8 +91,6 @@ public:
 
     VirtualFile GetBaseFile() const;
 
-    bool IsUpdate() const;
-
 protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
@@ -113,7 +109,6 @@ private:
 
     NCAHeader header{};
     bool has_rights_id{};
-    bool is_update{};
 
     Loader::ResultStatus status{};
 

src/core/file_sys/nca_metadata.cpp

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

src/core/file_sys/nca_metadata.h

@@ -4,10 +4,9 @@
 
 #pragma once
 
-#include <cstring>
+#include <array>
 #include <memory>
 #include <vector>
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/file_sys/vfs.h"

src/core/file_sys/registered_cache.cpp

@@ -37,12 +37,11 @@ static bool FollowsNcaIdFormat(std::string_view name) {
 static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bool second_hex_upper,
                                             bool within_two_digit) {
     if (!within_two_digit)
-        return fmt::format("/{}.nca", Common::HexArrayToString(nca_id, second_hex_upper));
+        return fmt::format("/{}.nca", HexArrayToString(nca_id, second_hex_upper));
 
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
-    return fmt::format("/000000{:02X}/{}.nca", hash[0],
-                       Common::HexArrayToString(nca_id, second_hex_upper));
+    return fmt::format("/000000{:02X}/{}.nca", hash[0], HexArrayToString(nca_id, second_hex_upper));
 }
 
 static std::string GetCNMTName(TitleType type, u64 title_id) {
@@ -77,13 +76,12 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     case NCAContentType::Control:
         return ContentRecordType::Control;
     case NCAContentType::Data:
-    case NCAContentType::Data_Unknown5:
         return ContentRecordType::Data;
     case NCAContentType::Manual:
         // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
         return ContentRecordType::Manual;
     default:
-        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", static_cast<u8>(type));
+        UNREACHABLE();
     }
 }
 
@@ -172,7 +170,7 @@ std::vector<NcaID> RegisteredCache::AccumulateFiles() const {
     std::vector<NcaID> ids;
     for (const auto& d2_dir : dir->GetSubdirectories()) {
         if (FollowsNcaIdFormat(d2_dir->GetName())) {
-            ids.push_back(Common::HexStringToArray<0x10, true>(d2_dir->GetName().substr(0, 0x20)));
+            ids.push_back(HexStringToArray<0x10, true>(d2_dir->GetName().substr(0, 0x20)));
             continue;
         }
 
@@ -183,21 +181,20 @@ std::vector<NcaID> RegisteredCache::AccumulateFiles() const {
             if (!FollowsNcaIdFormat(nca_dir->GetName()))
                 continue;
 
-            ids.push_back(Common::HexStringToArray<0x10, true>(nca_dir->GetName().substr(0, 0x20)));
+            ids.push_back(HexStringToArray<0x10, true>(nca_dir->GetName().substr(0, 0x20)));
         }
 
         for (const auto& nca_file : d2_dir->GetFiles()) {
             if (!FollowsNcaIdFormat(nca_file->GetName()))
                 continue;
 
-            ids.push_back(
-                Common::HexStringToArray<0x10, true>(nca_file->GetName().substr(0, 0x20)));
+            ids.push_back(HexStringToArray<0x10, true>(nca_file->GetName().substr(0, 0x20)));
         }
     }
 
     for (const auto& d2_file : dir->GetFiles()) {
         if (FollowsNcaIdFormat(d2_file->GetName()))
-            ids.push_back(Common::HexStringToArray<0x10, true>(d2_file->GetName().substr(0, 0x20)));
+            ids.push_back(HexStringToArray<0x10, true>(d2_file->GetName().substr(0, 0x20)));
     }
     return ids;
 }
@@ -216,11 +213,11 @@ void RegisteredCache::ProcessFiles(const std::vector<NcaID>& ids) {
 
         const auto section0 = nca->GetSubdirectories()[0];
 
-        for (const auto& section0_file : section0->GetFiles()) {
-            if (section0_file->GetExtension() != "cnmt")
+        for (const auto& file : section0->GetFiles()) {
+            if (file->GetExtension() != "cnmt")
                 continue;
 
-            meta.insert_or_assign(nca->GetTitleId(), CNMT(section0_file));
+            meta.insert_or_assign(nca->GetTitleId(), CNMT(file));
             meta_id.insert_or_assign(nca->GetTitleId(), id);
             break;
         }
@@ -254,8 +251,6 @@ RegisteredCache::RegisteredCache(VirtualDir dir_, RegisteredCacheParsingFunction
     Refresh();
 }
 
-RegisteredCache::~RegisteredCache() = default;
-
 bool RegisteredCache::HasEntry(u64 title_id, ContentRecordType type) const {
     return GetEntryRaw(title_id, type) != nullptr;
 }
@@ -264,18 +259,6 @@ bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {
     return GetEntryRaw(entry) != nullptr;
 }
 
-VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
-    const auto id = GetNcaIDFromMetadata(title_id, type);
-    if (id == boost::none)
-        return nullptr;
-
-    return GetFileAtID(id.get());
-}
-
-VirtualFile RegisteredCache::GetEntryUnparsed(RegisteredCacheEntry entry) const {
-    return GetEntryUnparsed(entry.title_id, entry.type);
-}
-
 VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) const {
     const auto id = GetNcaIDFromMetadata(title_id, type);
     if (id == boost::none)
@@ -356,7 +339,7 @@ std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
 }
 
 static std::shared_ptr<NCA> GetNCAFromXCIForID(std::shared_ptr<XCI> xci, const NcaID& id) {
-    const auto filename = fmt::format("{}.nca", Common::HexArrayToString(id, false));
+    const auto filename = fmt::format("{}.nca", HexArrayToString(id, false));
     const auto iter =
         std::find_if(xci->GetNCAs().begin(), xci->GetNCAs().end(),
                      [&filename](std::shared_ptr<NCA> nca) { return nca->GetName() == filename; });
@@ -378,7 +361,7 @@ InstallResult RegisteredCache::InstallEntry(std::shared_ptr<XCI> xci, bool overw
 
     // Install Metadata File
     const auto meta_id_raw = (*meta_iter)->GetName().substr(0, 32);
-    const auto meta_id = Common::HexStringToArray<16>(meta_id_raw);
+    const auto meta_id = HexStringToArray<16>(meta_id_raw);
 
     const auto res = RawInstallNCA(*meta_iter, copy, overwrite_if_exists, meta_id);
     if (res != InstallResult::Success)

src/core/file_sys/registered_cache.h

@@ -11,15 +11,14 @@
 #include <string>
 #include <vector>
 #include <boost/container/flat_map.hpp>
-#include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "content_archive.h"
+#include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
-class XCI;
 class CNMT;
+class XCI;
 
 using NcaID = std::array<u8, 0x10>;
 using RegisteredCacheParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
@@ -63,16 +62,12 @@ public:
     explicit RegisteredCache(VirtualDir dir,
                              RegisteredCacheParsingFunction parsing_function =
                                  [](const VirtualFile& file, const NcaID& id) { return file; });
-    ~RegisteredCache();
 
     void Refresh();
 
     bool HasEntry(u64 title_id, ContentRecordType type) const;
     bool HasEntry(RegisteredCacheEntry entry) const;
 
-    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;
 

src/core/file_sys/romfs_factory.cpp

@@ -2,61 +2,23 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <memory>
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
-#include "core/hle/kernel/process.h"
-#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
 
 RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     // Load the RomFS from the app
-    if (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
+    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(file)) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
     }
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id) {
+    // TODO(DarkLordZach): Use title id.
     return MakeResult<VirtualFile>(file);
 }
 
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {
-    switch (storage) {
-    case StorageId::NandSystem: {
-        const auto res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);
-        if (res == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        const auto romfs = res->GetRomFS();
-        if (romfs == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        return MakeResult<VirtualFile>(romfs);
-    }
-    case StorageId::NandUser: {
-        const auto res = Service::FileSystem::GetUserNANDContents()->GetEntry(title_id, type);
-        if (res == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        const auto romfs = res->GetRomFS();
-        if (romfs == nullptr) {
-            // TODO(DarkLordZach): Find the right error code to use here
-            return ResultCode(-1);
-        }
-        return MakeResult<VirtualFile>(romfs);
-    }
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
-    }
-}
-
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -4,35 +4,22 @@
 
 #pragma once
 
-#include <memory>
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace Loader {
 class AppLoader;
-} // namespace Loader
+}
 
 namespace FileSys {
 
-enum class ContentRecordType : u8;
-
-enum class StorageId : u8 {
-    None = 0,
-    Host = 1,
-    GameCard = 2,
-    NandSystem = 3,
-    NandUser = 4,
-    SdCard = 5,
-};
-
 /// File system interface to the RomFS archive
 class RomFSFactory {
 public:
     explicit RomFSFactory(Loader::AppLoader& app_loader);
 
-    ResultVal<VirtualFile> OpenCurrentProcess();
-    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);
+    ResultVal<VirtualFile> Open(u64 title_id);
 
 private:
     VirtualFile file;

src/core/file_sys/savedata_factory.cpp

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

src/core/file_sys/savedata_factory.h

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

src/core/file_sys/sdmc_factory.cpp

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

src/core/file_sys/sdmc_factory.h

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

src/core/file_sys/vfs.cpp

@@ -8,7 +8,6 @@
 #include "common/common_paths.h"
 #include "common/file_util.h"
 #include "common/logging/backend.h"
-#include "core/file_sys/mode.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
@@ -462,11 +461,4 @@ bool VfsRawCopy(VirtualFile src, VirtualFile dest) {
     std::vector<u8> data = src->ReadAllBytes();
     return dest->WriteBytes(data, 0) == data.size();
 }
-
-VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path) {
-    const auto res = rel->GetDirectoryRelative(path);
-    if (res == nullptr)
-        return rel->CreateDirectoryRelative(path);
-    return res;
-}
 } // namespace FileSys

src/core/file_sys/vfs.h

@@ -9,8 +9,9 @@
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include <boost/optional.hpp>
+#include "boost/optional.hpp"
 #include "common/common_types.h"
+#include "core/file_sys/mode.h"
 
 namespace FileSys {
 
@@ -18,8 +19,6 @@ class VfsDirectory;
 class VfsFile;
 class VfsFilesystem;
 
-enum class Mode : u32;
-
 // Convenience typedefs to use Vfs* interfaces
 using VirtualFilesystem = std::shared_ptr<VfsFilesystem>;
 using VirtualDir = std::shared_ptr<VfsDirectory>;
@@ -318,8 +317,4 @@ bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, size_t block
 // directory of src/dest.
 bool VfsRawCopy(VirtualFile src, VirtualFile dest);
 
-// Checks if the directory at path relative to rel exists. If it does, returns that. If it does not
-// it attempts to create it and returns the new dir or nullptr on failure.
-VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path);
-
 } // namespace FileSys

src/core/file_sys/vfs_real.cpp

@@ -341,6 +341,7 @@ std::shared_ptr<VfsFile> RealVfsDirectory::CreateFileRelative(std::string_view p
 
 std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateDirectoryRelative(std::string_view path) {
     const auto full_path = FileUtil::SanitizePath(this->path + DIR_SEP + std::string(path));
+    auto parent = std::string(FileUtil::GetParentPath(full_path));
     return base.CreateDirectory(full_path, perms);
 }
 

src/core/file_sys/xts_archive.cpp

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

src/core/file_sys/xts_archive.h

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

src/core/hle/ipc_helpers.h

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

src/core/hle/kernel/address_arbiter.cpp

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

src/core/hle/kernel/client_port.cpp

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

src/core/hle/kernel/client_port.h

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

src/core/hle/kernel/client_session.cpp

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

src/core/hle/kernel/client_session.h

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

src/core/hle/kernel/errors.h

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

src/core/hle/kernel/event.cpp

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

src/core/hle/kernel/event.h

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

src/core/hle/kernel/handle_table.cpp

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

src/core/hle/kernel/handle_table.h

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

src/core/hle/kernel/hle_ipc.cpp

@@ -13,12 +13,10 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_session.h"
@@ -53,9 +51,7 @@ SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
 
     if (!event) {
         // Create event if not provided
-        auto& kernel = Core::System::GetInstance().Kernel();
-        event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
+        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
     }
 
     event->Clear();
@@ -94,14 +90,12 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
             rp.Skip(2, false);
         }
         if (incoming) {
-            auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
             // Populate the object lists with the data in the IPC request.
             for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
-                copy_objects.push_back(handle_table.GetGeneric(rp.Pop<Handle>()));
+                copy_objects.push_back(Kernel::g_handle_table.GetGeneric(rp.Pop<Handle>()));
             }
             for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_move; ++handle) {
-                move_objects.push_back(handle_table.GetGeneric(rp.Pop<Handle>()));
+                move_objects.push_back(Kernel::g_handle_table.GetGeneric(rp.Pop<Handle>()));
             }
         } else {
             // For responses we just ignore the handles, they're empty and will be populated when
@@ -236,19 +230,17 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread)
         ASSERT(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
         ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);
 
-        auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
         // We don't make a distinction between copy and move handles when translating since HLE
         // services don't deal with handles directly. However, the guest applications might check
         // for specific values in each of these descriptors.
         for (auto& object : copy_objects) {
             ASSERT(object != nullptr);
-            dst_cmdbuf[current_offset++] = handle_table.Create(object).Unwrap();
+            dst_cmdbuf[current_offset++] = Kernel::g_handle_table.Create(object).Unwrap();
         }
 
         for (auto& object : move_objects) {
             ASSERT(object != nullptr);
-            dst_cmdbuf[current_offset++] = handle_table.Create(object).Unwrap();
+            dst_cmdbuf[current_offset++] = Kernel::g_handle_table.Create(object).Unwrap();
         }
     }
 

src/core/hle/kernel/kernel.cpp

@@ -2,291 +2,38 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
-#include <atomic>
-#include <memory>
-#include <mutex>
-#include <utility>
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-
-#include "core/core.h"
-#include "core/core_timing.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
-#include "core/hle/lock.h"
-#include "core/hle/result.h"
 
 namespace Kernel {
 
-/**
- * Callback that will wake up the thread it was scheduled for
- * @param thread_handle The handle of the thread that's been awoken
- * @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
- */
-static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_late) {
-    const auto proper_handle = static_cast<Handle>(thread_handle);
-    auto& system = Core::System::GetInstance();
+std::atomic<u32> Object::next_object_id{0};
 
-    // Lock the global kernel mutex when we enter the kernel HLE.
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+/// Initialize the kernel
+void Init() {
+    Kernel::ResourceLimitsInit();
+    Kernel::ThreadingInit();
+    Kernel::TimersInit();
 
-    SharedPtr<Thread> thread =
-        system.Kernel().RetrieveThreadFromWakeupCallbackHandleTable(proper_handle);
-    if (thread == nullptr) {
-        LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
-        return;
-    }
-
-    bool resume = true;
-
-    if (thread->status == ThreadStatus::WaitSynchAny ||
-        thread->status == ThreadStatus::WaitSynchAll ||
-        thread->status == ThreadStatus::WaitHLEEvent) {
-        // Remove the thread from each of its waiting objects' waitlists
-        for (auto& object : thread->wait_objects) {
-            object->RemoveWaitingThread(thread.get());
-        }
-        thread->wait_objects.clear();
-
-        // Invoke the wakeup callback before clearing the wait objects
-        if (thread->wakeup_callback) {
-            resume = thread->wakeup_callback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
-        }
-    }
-
-    if (thread->mutex_wait_address != 0 || thread->condvar_wait_address != 0 ||
-        thread->wait_handle) {
-        ASSERT(thread->status == ThreadStatus::WaitMutex);
-        thread->mutex_wait_address = 0;
-        thread->condvar_wait_address = 0;
-        thread->wait_handle = 0;
-
-        auto lock_owner = thread->lock_owner;
-        // Threads waking up by timeout from WaitProcessWideKey do not perform priority inheritance
-        // and don't have a lock owner unless SignalProcessWideKey was called first and the thread
-        // wasn't awakened due to the mutex already being acquired.
-        if (lock_owner) {
-            lock_owner->RemoveMutexWaiter(thread);
-        }
-    }
-
-    if (thread->arb_wait_address != 0) {
-        ASSERT(thread->status == ThreadStatus::WaitArb);
-        thread->arb_wait_address = 0;
-    }
-
-    if (resume) {
-        thread->ResumeFromWait();
-    }
-}
-
-/// The timer callback event, called when a timer is fired
-static void TimerCallback(u64 timer_handle, int cycles_late) {
-    const auto proper_handle = static_cast<Handle>(timer_handle);
-    auto& system = Core::System::GetInstance();
-    SharedPtr<Timer> timer = system.Kernel().RetrieveTimerFromCallbackHandleTable(proper_handle);
-
-    if (timer == nullptr) {
-        LOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
-        return;
-    }
-
-    timer->Signal(cycles_late);
-}
-
-struct KernelCore::Impl {
-    void Initialize(KernelCore& kernel) {
-        Shutdown();
-
-        InitializeResourceLimits(kernel);
-        InitializeThreads();
-        InitializeTimers();
-    }
-
-    void Shutdown() {
-        next_object_id = 0;
-        next_process_id = 10;
-        next_thread_id = 1;
-
-        process_list.clear();
-
-        handle_table.Clear();
-        resource_limits.fill(nullptr);
-
-        thread_wakeup_callback_handle_table.Clear();
-        thread_wakeup_event_type = nullptr;
-
-        timer_callback_handle_table.Clear();
-        timer_callback_event_type = nullptr;
-    }
-
-    void InitializeResourceLimits(KernelCore& kernel) {
-        // Create the four resource limits that the system uses
-        // Create the APPLICATION resource limit
-        SharedPtr<ResourceLimit> resource_limit = ResourceLimit::Create(kernel, "Applications");
-        resource_limit->max_priority = 0x18;
-        resource_limit->max_commit = 0x4000000;
-        resource_limit->max_threads = 0x20;
-        resource_limit->max_events = 0x20;
-        resource_limit->max_mutexes = 0x20;
-        resource_limit->max_semaphores = 0x8;
-        resource_limit->max_timers = 0x8;
-        resource_limit->max_shared_mems = 0x10;
-        resource_limit->max_address_arbiters = 0x2;
-        resource_limit->max_cpu_time = 0x1E;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::APPLICATION)] = resource_limit;
-
-        // Create the SYS_APPLET resource limit
-        resource_limit = ResourceLimit::Create(kernel, "System Applets");
-        resource_limit->max_priority = 0x4;
-        resource_limit->max_commit = 0x5E00000;
-        resource_limit->max_threads = 0x1D;
-        resource_limit->max_events = 0xB;
-        resource_limit->max_mutexes = 0x8;
-        resource_limit->max_semaphores = 0x4;
-        resource_limit->max_timers = 0x4;
-        resource_limit->max_shared_mems = 0x8;
-        resource_limit->max_address_arbiters = 0x3;
-        resource_limit->max_cpu_time = 0x2710;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::SYS_APPLET)] = resource_limit;
-
-        // Create the LIB_APPLET resource limit
-        resource_limit = ResourceLimit::Create(kernel, "Library Applets");
-        resource_limit->max_priority = 0x4;
-        resource_limit->max_commit = 0x600000;
-        resource_limit->max_threads = 0xE;
-        resource_limit->max_events = 0x8;
-        resource_limit->max_mutexes = 0x8;
-        resource_limit->max_semaphores = 0x4;
-        resource_limit->max_timers = 0x4;
-        resource_limit->max_shared_mems = 0x8;
-        resource_limit->max_address_arbiters = 0x1;
-        resource_limit->max_cpu_time = 0x2710;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::LIB_APPLET)] = resource_limit;
-
-        // Create the OTHER resource limit
-        resource_limit = ResourceLimit::Create(kernel, "Others");
-        resource_limit->max_priority = 0x4;
-        resource_limit->max_commit = 0x2180000;
-        resource_limit->max_threads = 0xE1;
-        resource_limit->max_events = 0x108;
-        resource_limit->max_mutexes = 0x25;
-        resource_limit->max_semaphores = 0x43;
-        resource_limit->max_timers = 0x2C;
-        resource_limit->max_shared_mems = 0x1F;
-        resource_limit->max_address_arbiters = 0x2D;
-        resource_limit->max_cpu_time = 0x3E8;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::OTHER)] = resource_limit;
-    }
-
-    void InitializeThreads() {
-        thread_wakeup_event_type =
-            CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
-    }
-
-    void InitializeTimers() {
-        timer_callback_handle_table.Clear();
-        timer_callback_event_type = CoreTiming::RegisterEvent("TimerCallback", TimerCallback);
-    }
-
-    std::atomic<u32> next_object_id{0};
+    Object::next_object_id = 0;
     // TODO(Subv): Start the process ids from 10 for now, as lower PIDs are
     // reserved for low-level services
-    std::atomic<u32> next_process_id{10};
-    std::atomic<u32> next_thread_id{1};
-
-    // Lists all processes that exist in the current session.
-    std::vector<SharedPtr<Process>> process_list;
-
-    Kernel::HandleTable handle_table;
-    std::array<SharedPtr<ResourceLimit>, 4> resource_limits;
-
-    /// The event type of the generic timer callback event
-    CoreTiming::EventType* timer_callback_event_type = nullptr;
-    // TODO(yuriks): This can be removed if Timer objects are explicitly pooled in the future,
-    // allowing us to simply use a pool index or similar.
-    Kernel::HandleTable timer_callback_handle_table;
-
-    CoreTiming::EventType* thread_wakeup_event_type = nullptr;
-    // TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future,
-    // allowing us to simply use a pool index or similar.
-    Kernel::HandleTable thread_wakeup_callback_handle_table;
-};
-
-KernelCore::KernelCore() : impl{std::make_unique<Impl>()} {}
-KernelCore::~KernelCore() {
-    Shutdown();
+    Process::next_process_id = 10;
 }
 
-void KernelCore::Initialize() {
-    impl->Initialize(*this);
-}
+/// Shutdown the kernel
+void Shutdown() {
+    // Free all kernel objects
+    g_handle_table.Clear();
 
-void KernelCore::Shutdown() {
-    impl->Shutdown();
-}
+    Kernel::ThreadingShutdown();
 
-Kernel::HandleTable& KernelCore::HandleTable() {
-    return impl->handle_table;
-}
-
-const Kernel::HandleTable& KernelCore::HandleTable() const {
-    return impl->handle_table;
-}
-
-SharedPtr<ResourceLimit> KernelCore::ResourceLimitForCategory(
-    ResourceLimitCategory category) const {
-    return impl->resource_limits.at(static_cast<std::size_t>(category));
-}
-
-SharedPtr<Thread> KernelCore::RetrieveThreadFromWakeupCallbackHandleTable(Handle handle) const {
-    return impl->thread_wakeup_callback_handle_table.Get<Thread>(handle);
-}
-
-SharedPtr<Timer> KernelCore::RetrieveTimerFromCallbackHandleTable(Handle handle) const {
-    return impl->timer_callback_handle_table.Get<Timer>(handle);
-}
-
-void KernelCore::AppendNewProcess(SharedPtr<Process> process) {
-    impl->process_list.push_back(std::move(process));
-}
-
-u32 KernelCore::CreateNewObjectID() {
-    return impl->next_object_id++;
-}
-
-u32 KernelCore::CreateNewThreadID() {
-    return impl->next_thread_id++;
-}
-
-u32 KernelCore::CreateNewProcessID() {
-    return impl->next_process_id++;
-}
-
-ResultVal<Handle> KernelCore::CreateTimerCallbackHandle(const SharedPtr<Timer>& timer) {
-    return impl->timer_callback_handle_table.Create(timer);
-}
-
-CoreTiming::EventType* KernelCore::ThreadWakeupCallbackEventType() const {
-    return impl->thread_wakeup_event_type;
-}
-
-CoreTiming::EventType* KernelCore::TimerCallbackEventType() const {
-    return impl->timer_callback_event_type;
-}
-
-Kernel::HandleTable& KernelCore::ThreadWakeupCallbackHandleTable() {
-    return impl->thread_wakeup_callback_handle_table;
-}
-
-const Kernel::HandleTable& KernelCore::ThreadWakeupCallbackHandleTable() const {
-    return impl->thread_wakeup_callback_handle_table;
+    Kernel::TimersShutdown();
+    Kernel::ResourceLimitsShutdown();
 }
 
 } // namespace Kernel

src/core/hle/kernel/kernel.h

@@ -4,93 +4,14 @@
 
 #pragma once
 
-#include "core/hle/kernel/object.h"
-
-template <typename T>
-class ResultVal;
-
-namespace CoreTiming {
-struct EventType;
-}
+#include "common/common_types.h"
 
 namespace Kernel {
 
-class HandleTable;
-class Process;
-class ResourceLimit;
-class Thread;
-class Timer;
+/// Initialize the kernel with the specified system mode.
+void Init();
 
-enum class ResourceLimitCategory : u8;
-
-/// Represents a single instance of the kernel.
-class KernelCore {
-public:
-    KernelCore();
-    ~KernelCore();
-
-    KernelCore(const KernelCore&) = delete;
-    KernelCore& operator=(const KernelCore&) = delete;
-
-    KernelCore(KernelCore&&) = delete;
-    KernelCore& operator=(KernelCore&&) = delete;
-
-    /// Resets the kernel to a clean slate for use.
-    void Initialize();
-
-    /// Clears all resources in use by the kernel instance.
-    void Shutdown();
-
-    /// Provides a reference to the handle table.
-    Kernel::HandleTable& HandleTable();
-
-    /// Provides a const reference to the handle table.
-    const Kernel::HandleTable& HandleTable() const;
-
-    /// Retrieves a shared pointer to a ResourceLimit identified by the given category.
-    SharedPtr<ResourceLimit> ResourceLimitForCategory(ResourceLimitCategory category) const;
-
-    /// Retrieves a shared pointer to a Thread instance within the thread wakeup handle table.
-    SharedPtr<Thread> RetrieveThreadFromWakeupCallbackHandleTable(Handle handle) const;
-
-    /// Retrieves a shared pointer to a Timer instance within the timer callback handle table.
-    SharedPtr<Timer> RetrieveTimerFromCallbackHandleTable(Handle handle) const;
-
-    /// Adds the given shared pointer to an internal list of active processes.
-    void AppendNewProcess(SharedPtr<Process> process);
-
-private:
-    friend class Object;
-    friend class Process;
-    friend class Thread;
-    friend class Timer;
-
-    /// Creates a new object ID, incrementing the internal object ID counter.
-    u32 CreateNewObjectID();
-
-    /// Creates a new process ID, incrementing the internal process ID counter;
-    u32 CreateNewProcessID();
-
-    /// Creates a new thread ID, incrementing the internal thread ID counter.
-    u32 CreateNewThreadID();
-
-    /// Creates a timer callback handle for the given timer.
-    ResultVal<Handle> CreateTimerCallbackHandle(const SharedPtr<Timer>& timer);
-
-    /// Retrieves the event type used for thread wakeup callbacks.
-    CoreTiming::EventType* ThreadWakeupCallbackEventType() const;
-
-    /// Retrieves the event type used for timer callbacks.
-    CoreTiming::EventType* TimerCallbackEventType() const;
-
-    /// Provides a reference to the thread wakeup callback handle table.
-    Kernel::HandleTable& ThreadWakeupCallbackHandleTable();
-
-    /// Provides a const reference to the thread wakeup callback handle table.
-    const Kernel::HandleTable& ThreadWakeupCallbackHandleTable() const;
-
-    struct Impl;
-    std::unique_ptr<Impl> impl;
-};
+/// Shutdown the kernel
+void Shutdown();
 
 } // namespace Kernel

src/core/hle/kernel/mutex.cpp

@@ -58,15 +58,15 @@ static void TransferMutexOwnership(VAddr mutex_addr, SharedPtr<Thread> current_t
     }
 }
 
-ResultCode Mutex::TryAcquire(HandleTable& handle_table, VAddr address, Handle holding_thread_handle,
+ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
                              Handle requesting_thread_handle) {
     // The mutex address must be 4-byte aligned
     if ((address % sizeof(u32)) != 0) {
         return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidAddress);
     }
 
-    SharedPtr<Thread> holding_thread = handle_table.Get<Thread>(holding_thread_handle);
-    SharedPtr<Thread> requesting_thread = handle_table.Get<Thread>(requesting_thread_handle);
+    SharedPtr<Thread> holding_thread = g_handle_table.Get<Thread>(holding_thread_handle);
+    SharedPtr<Thread> requesting_thread = g_handle_table.Get<Thread>(requesting_thread_handle);
 
     // TODO(Subv): It is currently unknown if it is possible to lock a mutex in behalf of another
     // thread.

src/core/hle/kernel/mutex.h

@@ -11,7 +11,6 @@ union ResultCode;
 
 namespace Kernel {
 
-class HandleTable;
 class Thread;
 
 class Mutex final {
@@ -22,8 +21,8 @@ public:
     static constexpr u32 MutexOwnerMask = 0xBFFFFFFF;
 
     /// Attempts to acquire a mutex at the specified address.
-    static ResultCode TryAcquire(HandleTable& handle_table, VAddr address,
-                                 Handle holding_thread_handle, Handle requesting_thread_handle);
+    static ResultCode TryAcquire(VAddr address, Handle holding_thread_handle,
+                                 Handle requesting_thread_handle);
 
     /// Releases the mutex at the specified address.
     static ResultCode Release(VAddr address);

src/core/hle/kernel/object.cpp

@@ -3,12 +3,10 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 
 namespace Kernel {
 
-Object::Object(KernelCore& kernel) : kernel{kernel}, object_id{kernel.CreateNewObjectID()} {}
 Object::~Object() = default;
 
 bool Object::IsWaitable() const {

src/core/hle/kernel/object.h

@@ -14,8 +14,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 using Handle = u32;
 
 enum class HandleType : u32 {
@@ -42,7 +40,6 @@ enum class ResetType {
 
 class Object : NonCopyable {
 public:
-    explicit Object(KernelCore& kernel);
     virtual ~Object();
 
     /// Returns a unique identifier for the object. For debugging purposes only.
@@ -64,16 +61,15 @@ public:
      */
     bool IsWaitable() const;
 
-protected:
-    /// The kernel instance this object was created under.
-    KernelCore& kernel;
+public:
+    static std::atomic<u32> next_object_id;
 
 private:
     friend void intrusive_ptr_add_ref(Object*);
     friend void intrusive_ptr_release(Object*);
 
     std::atomic<u32> ref_count{0};
-    std::atomic<u32> object_id{0};
+    std::atomic<u32> object_id{next_object_id++};
 };
 
 // Special functions used by boost::instrusive_ptr to do automatic ref-counting

src/core/hle/kernel/process.cpp

@@ -8,7 +8,6 @@
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
@@ -17,26 +16,30 @@
 
 namespace Kernel {
 
-SharedPtr<CodeSet> CodeSet::Create(KernelCore& kernel, std::string name) {
-    SharedPtr<CodeSet> codeset(new CodeSet(kernel));
+// Lists all processes that exist in the current session.
+static std::vector<SharedPtr<Process>> process_list;
+
+SharedPtr<CodeSet> CodeSet::Create(std::string name) {
+    SharedPtr<CodeSet> codeset(new CodeSet);
     codeset->name = std::move(name);
     return codeset;
 }
 
-CodeSet::CodeSet(KernelCore& kernel) : Object{kernel} {}
-CodeSet::~CodeSet() = default;
+CodeSet::CodeSet() {}
+CodeSet::~CodeSet() {}
 
-SharedPtr<Process> Process::Create(KernelCore& kernel, std::string&& name) {
-    SharedPtr<Process> process(new Process(kernel));
+u32 Process::next_process_id;
+
+SharedPtr<Process> Process::Create(std::string&& name) {
+    SharedPtr<Process> process(new Process);
 
     process->name = std::move(name);
     process->flags.raw = 0;
     process->flags.memory_region.Assign(MemoryRegion::APPLICATION);
     process->status = ProcessStatus::Created;
     process->program_id = 0;
-    process->process_id = kernel.CreateNewProcessID();
 
-    kernel.AppendNewProcess(process);
+    process_list.push_back(process);
     return process;
 }
 
@@ -125,7 +128,7 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
     vm_manager.LogLayout();
     status = ProcessStatus::Running;
 
-    Kernel::SetupMainThread(kernel, entry_point, main_thread_priority, this);
+    Kernel::SetupMainThread(entry_point, main_thread_priority, this);
 }
 
 void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {
@@ -228,7 +231,22 @@ ResultCode Process::UnmapMemory(VAddr dst_addr, VAddr /*src_addr*/, u64 size) {
     return vm_manager.UnmapRange(dst_addr, size);
 }
 
-Kernel::Process::Process(KernelCore& kernel) : Object{kernel} {}
+Kernel::Process::Process() {}
 Kernel::Process::~Process() {}
 
+void ClearProcessList() {
+    process_list.clear();
+}
+
+SharedPtr<Process> GetProcessById(u32 process_id) {
+    auto itr = std::find_if(
+        process_list.begin(), process_list.end(),
+        [&](const SharedPtr<Process>& process) { return process->process_id == process_id; });
+
+    if (itr == process_list.end())
+        return nullptr;
+
+    return *itr;
+}
+
 } // namespace Kernel

src/core/hle/kernel/process.h

@@ -19,8 +19,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 struct AddressMapping {
     // Address and size must be page-aligned
     VAddr address;
@@ -64,7 +62,7 @@ struct CodeSet final : public Object {
         u32 size = 0;
     };
 
-    static SharedPtr<CodeSet> Create(KernelCore& kernel, std::string name);
+    static SharedPtr<CodeSet> Create(std::string name);
 
     std::string GetTypeName() const override {
         return "CodeSet";
@@ -111,13 +109,13 @@ struct CodeSet final : public Object {
     std::string name;
 
 private:
-    explicit CodeSet(KernelCore& kernel);
+    CodeSet();
     ~CodeSet() override;
 };
 
 class Process final : public Object {
 public:
-    static SharedPtr<Process> Create(KernelCore& kernel, std::string&& name);
+    static SharedPtr<Process> Create(std::string&& name);
 
     std::string GetTypeName() const override {
         return "Process";
@@ -131,6 +129,8 @@ public:
         return HANDLE_TYPE;
     }
 
+    static u32 next_process_id;
+
     /// Title ID corresponding to the process
     u64 program_id;
 
@@ -157,8 +157,8 @@ public:
     /// Current status of the process
     ProcessStatus status;
 
-    /// The ID of this process
-    u32 process_id = 0;
+    /// The id of this process
+    u32 process_id = next_process_id++;
 
     /**
      * Parses a list of kernel capability descriptors (as found in the ExHeader) and applies them
@@ -206,8 +206,13 @@ public:
     ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
 
 private:
-    explicit Process(KernelCore& kernel);
+    Process();
     ~Process() override;
 };
 
+void ClearProcessList();
+
+/// Retrieves a process from the current list of processes.
+SharedPtr<Process> GetProcessById(u32 process_id);
+
 } // namespace Kernel

src/core/hle/kernel/resource_limit.cpp

@@ -9,16 +9,31 @@
 
 namespace Kernel {
 
-ResourceLimit::ResourceLimit(KernelCore& kernel) : Object{kernel} {}
-ResourceLimit::~ResourceLimit() = default;
+static SharedPtr<ResourceLimit> resource_limits[4];
 
-SharedPtr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel, std::string name) {
-    SharedPtr<ResourceLimit> resource_limit(new ResourceLimit(kernel));
+ResourceLimit::ResourceLimit() {}
+ResourceLimit::~ResourceLimit() {}
+
+SharedPtr<ResourceLimit> ResourceLimit::Create(std::string name) {
+    SharedPtr<ResourceLimit> resource_limit(new ResourceLimit);
 
     resource_limit->name = std::move(name);
     return resource_limit;
 }
 
+SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory category) {
+    switch (category) {
+    case ResourceLimitCategory::APPLICATION:
+    case ResourceLimitCategory::SYS_APPLET:
+    case ResourceLimitCategory::LIB_APPLET:
+    case ResourceLimitCategory::OTHER:
+        return resource_limits[static_cast<u8>(category)];
+    default:
+        LOG_CRITICAL(Kernel, "Unknown resource limit category");
+        UNREACHABLE();
+    }
+}
+
 s32 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {
     switch (resource) {
     case ResourceType::Commit:
@@ -74,4 +89,66 @@ u32 ResourceLimit::GetMaxResourceValue(ResourceType resource) const {
         return 0;
     }
 }
+
+void ResourceLimitsInit() {
+    // Create the four resource limits that the system uses
+    // Create the APPLICATION resource limit
+    SharedPtr<ResourceLimit> resource_limit = ResourceLimit::Create("Applications");
+    resource_limit->max_priority = 0x18;
+    resource_limit->max_commit = 0x4000000;
+    resource_limit->max_threads = 0x20;
+    resource_limit->max_events = 0x20;
+    resource_limit->max_mutexes = 0x20;
+    resource_limit->max_semaphores = 0x8;
+    resource_limit->max_timers = 0x8;
+    resource_limit->max_shared_mems = 0x10;
+    resource_limit->max_address_arbiters = 0x2;
+    resource_limit->max_cpu_time = 0x1E;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::APPLICATION)] = resource_limit;
+
+    // Create the SYS_APPLET resource limit
+    resource_limit = ResourceLimit::Create("System Applets");
+    resource_limit->max_priority = 0x4;
+    resource_limit->max_commit = 0x5E00000;
+    resource_limit->max_threads = 0x1D;
+    resource_limit->max_events = 0xB;
+    resource_limit->max_mutexes = 0x8;
+    resource_limit->max_semaphores = 0x4;
+    resource_limit->max_timers = 0x4;
+    resource_limit->max_shared_mems = 0x8;
+    resource_limit->max_address_arbiters = 0x3;
+    resource_limit->max_cpu_time = 0x2710;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::SYS_APPLET)] = resource_limit;
+
+    // Create the LIB_APPLET resource limit
+    resource_limit = ResourceLimit::Create("Library Applets");
+    resource_limit->max_priority = 0x4;
+    resource_limit->max_commit = 0x600000;
+    resource_limit->max_threads = 0xE;
+    resource_limit->max_events = 0x8;
+    resource_limit->max_mutexes = 0x8;
+    resource_limit->max_semaphores = 0x4;
+    resource_limit->max_timers = 0x4;
+    resource_limit->max_shared_mems = 0x8;
+    resource_limit->max_address_arbiters = 0x1;
+    resource_limit->max_cpu_time = 0x2710;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::LIB_APPLET)] = resource_limit;
+
+    // Create the OTHER resource limit
+    resource_limit = ResourceLimit::Create("Others");
+    resource_limit->max_priority = 0x4;
+    resource_limit->max_commit = 0x2180000;
+    resource_limit->max_threads = 0xE1;
+    resource_limit->max_events = 0x108;
+    resource_limit->max_mutexes = 0x25;
+    resource_limit->max_semaphores = 0x43;
+    resource_limit->max_timers = 0x2C;
+    resource_limit->max_shared_mems = 0x1F;
+    resource_limit->max_address_arbiters = 0x2D;
+    resource_limit->max_cpu_time = 0x3E8;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::OTHER)] = resource_limit;
+}
+
+void ResourceLimitsShutdown() {}
+
 } // namespace Kernel

src/core/hle/kernel/resource_limit.h

@@ -9,8 +9,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 enum class ResourceLimitCategory : u8 {
     APPLICATION = 0,
     SYS_APPLET = 1,
@@ -36,7 +34,14 @@ public:
     /**
      * Creates a resource limit object.
      */
-    static SharedPtr<ResourceLimit> Create(KernelCore& kernel, std::string name = "Unknown");
+    static SharedPtr<ResourceLimit> Create(std::string name = "Unknown");
+
+    /**
+     * Retrieves the resource limit associated with the specified resource limit category.
+     * @param category The resource limit category
+     * @returns The resource limit associated with the category
+     */
+    static SharedPtr<ResourceLimit> GetForCategory(ResourceLimitCategory category);
 
     std::string GetTypeName() const override {
         return "ResourceLimit";
@@ -108,8 +113,14 @@ public:
     s32 current_cpu_time = 0;
 
 private:
-    explicit ResourceLimit(KernelCore& kernel);
+    ResourceLimit();
     ~ResourceLimit() override;
 };
 
+/// Initializes the resource limits
+void ResourceLimitsInit();
+
+// Destroys the resource limits
+void ResourceLimitsShutdown();
+
 } // namespace Kernel

src/core/hle/kernel/scheduler.cpp

@@ -17,7 +17,7 @@ namespace Kernel {
 
 std::mutex Scheduler::scheduler_mutex;
 
-Scheduler::Scheduler(Core::ARM_Interface* cpu_core) : cpu_core(cpu_core) {}
+Scheduler::Scheduler(ARM_Interface* cpu_core) : cpu_core(cpu_core) {}
 
 Scheduler::~Scheduler() {
     for (auto& thread : thread_list) {

src/core/hle/kernel/scheduler.h

@@ -11,15 +11,13 @@
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 
-namespace Core {
 class ARM_Interface;
-}
 
 namespace Kernel {
 
 class Scheduler final {
 public:
-    explicit Scheduler(Core::ARM_Interface* cpu_core);
+    explicit Scheduler(ARM_Interface* cpu_core);
     ~Scheduler();
 
     /// Returns whether there are any threads that are ready to run.
@@ -72,7 +70,7 @@ private:
 
     SharedPtr<Thread> current_thread = nullptr;
 
-    Core::ARM_Interface* cpu_core;
+    ARM_Interface* cpu_core;
 
     static std::mutex scheduler_mutex;
 };

src/core/hle/kernel/server_port.cpp

@@ -13,8 +13,8 @@
 
 namespace Kernel {
 
-ServerPort::ServerPort(KernelCore& kernel) : WaitObject{kernel} {}
-ServerPort::~ServerPort() = default;
+ServerPort::ServerPort() {}
+ServerPort::~ServerPort() {}
 
 ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {
     if (pending_sessions.empty()) {
@@ -36,10 +36,10 @@ void ServerPort::Acquire(Thread* thread) {
 }
 
 std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair(
-    KernelCore& kernel, u32 max_sessions, std::string name) {
+    u32 max_sessions, std::string name) {
 
-    SharedPtr<ServerPort> server_port(new ServerPort(kernel));
-    SharedPtr<ClientPort> client_port(new ClientPort(kernel));
+    SharedPtr<ServerPort> server_port(new ServerPort);
+    SharedPtr<ClientPort> client_port(new ClientPort);
 
     server_port->name = name + "_Server";
     client_port->name = name + "_Client";

src/core/hle/kernel/server_port.h

@@ -15,7 +15,6 @@
 namespace Kernel {
 
 class ClientPort;
-class KernelCore;
 class ServerSession;
 class SessionRequestHandler;
 
@@ -24,13 +23,12 @@ public:
     /**
      * Creates a pair of ServerPort and an associated ClientPort.
      *
-     * @param kernel The kernel instance to create the port pair under.
      * @param max_sessions Maximum number of sessions to the port
      * @param name Optional name of the ports
      * @return The created port tuple
      */
     static std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> CreatePortPair(
-        KernelCore& kernel, u32 max_sessions, std::string name = "UnknownPort");
+        u32 max_sessions, std::string name = "UnknownPort");
 
     std::string GetTypeName() const override {
         return "ServerPort";
@@ -71,7 +69,7 @@ public:
     void Acquire(Thread* thread) override;
 
 private:
-    explicit ServerPort(KernelCore& kernel);
+    ServerPort();
     ~ServerPort() override;
 };
 

src/core/hle/kernel/server_session.cpp

@@ -13,7 +13,6 @@
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/session.h"
@@ -21,7 +20,7 @@
 
 namespace Kernel {
 
-ServerSession::ServerSession(KernelCore& kernel) : WaitObject{kernel} {}
+ServerSession::ServerSession() = default;
 ServerSession::~ServerSession() {
     // This destructor will be called automatically when the last ServerSession handle is closed by
     // the emulated application.
@@ -36,8 +35,8 @@ ServerSession::~ServerSession() {
     parent->server = nullptr;
 }
 
-ResultVal<SharedPtr<ServerSession>> ServerSession::Create(KernelCore& kernel, std::string name) {
-    SharedPtr<ServerSession> server_session(new ServerSession(kernel));
+ResultVal<SharedPtr<ServerSession>> ServerSession::Create(std::string name) {
+    SharedPtr<ServerSession> server_session(new ServerSession);
 
     server_session->name = std::move(name);
     server_session->parent = nullptr;
@@ -105,10 +104,11 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // The ServerSession received a sync request, this means that there's new data available
     // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or
     // similar.
+
     Kernel::HLERequestContext context(this);
     u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
     context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(),
-                                              kernel.HandleTable());
+                                              Kernel::g_handle_table);
 
     ResultCode result = RESULT_SUCCESS;
     // If the session has been converted to a domain, handle the domain request
@@ -160,11 +160,10 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     return result;
 }
 
-ServerSession::SessionPair ServerSession::CreateSessionPair(KernelCore& kernel,
-                                                            const std::string& name,
+ServerSession::SessionPair ServerSession::CreateSessionPair(const std::string& name,
                                                             SharedPtr<ClientPort> port) {
-    auto server_session = ServerSession::Create(kernel, name + "_Server").Unwrap();
-    SharedPtr<ClientSession> client_session(new ClientSession(kernel));
+    auto server_session = ServerSession::Create(name + "_Server").Unwrap();
+    SharedPtr<ClientSession> client_session(new ClientSession);
     client_session->name = name + "_Client";
 
     std::shared_ptr<Session> parent(new Session);

src/core/hle/kernel/server_session.h

@@ -15,14 +15,13 @@
 
 namespace Kernel {
 
-class ClientPort;
 class ClientSession;
-class HLERequestContext;
-class KernelCore;
+class ClientPort;
 class ServerSession;
 class Session;
 class SessionRequestHandler;
 class Thread;
+class HLERequestContext;
 
 /**
  * Kernel object representing the server endpoint of an IPC session. Sessions are the basic CTR-OS
@@ -51,12 +50,11 @@ public:
 
     /**
      * Creates a pair of ServerSession and an associated ClientSession.
-     * @param kernel      The kernal instance to create the session pair under.
      * @param name        Optional name of the ports.
      * @param client_port Optional The ClientPort that spawned this session.
      * @return The created session tuple
      */
-    static SessionPair CreateSessionPair(KernelCore& kernel, const std::string& name = "Unknown",
+    static SessionPair CreateSessionPair(const std::string& name = "Unknown",
                                          SharedPtr<ClientPort> client_port = nullptr);
 
     /**
@@ -113,18 +111,16 @@ public:
     }
 
 private:
-    explicit ServerSession(KernelCore& kernel);
+    ServerSession();
     ~ServerSession() override;
 
     /**
      * Creates a server session. The server session can have an optional HLE handler,
      * which will be invoked to handle the IPC requests that this session receives.
-     * @param kernel The kernel instance to create this server session under.
      * @param name Optional name of the server session.
      * @return The created server session
      */
-    static ResultVal<SharedPtr<ServerSession>> Create(KernelCore& kernel,
-                                                      std::string name = "Unknown");
+    static ResultVal<SharedPtr<ServerSession>> Create(std::string name = "Unknown");
 
     /// Handles a SyncRequest to a domain, forwarding the request to the proper object or closing an
     /// object handle.

src/core/hle/kernel/shared_memory.cpp

@@ -13,14 +13,14 @@
 
 namespace Kernel {
 
-SharedMemory::SharedMemory(KernelCore& kernel) : Object{kernel} {}
-SharedMemory::~SharedMemory() = default;
+SharedMemory::SharedMemory() {}
+SharedMemory::~SharedMemory() {}
 
-SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, SharedPtr<Process> owner_process,
-                                             u64 size, MemoryPermission permissions,
+SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u64 size,
+                                             MemoryPermission permissions,
                                              MemoryPermission other_permissions, VAddr address,
                                              MemoryRegion region, std::string name) {
-    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
+    SharedPtr<SharedMemory> shared_memory(new SharedMemory);
 
     shared_memory->owner_process = std::move(owner_process);
     shared_memory->name = std::move(name);
@@ -59,10 +59,12 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, SharedPtr<Proce
     return shared_memory;
 }
 
-SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
-    KernelCore& kernel, std::shared_ptr<std::vector<u8>> heap_block, u32 offset, u32 size,
-    MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
-    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
+SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
+                                                      u32 offset, u32 size,
+                                                      MemoryPermission permissions,
+                                                      MemoryPermission other_permissions,
+                                                      std::string name) {
+    SharedPtr<SharedMemory> shared_memory(new SharedMemory);
 
     shared_memory->owner_process = nullptr;
     shared_memory->name = std::move(name);
@@ -99,7 +101,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
         static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
         LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
                   GetObjectId(), address, name);
-        return ERR_INVALID_MEMORY_PERMISSIONS;
+        return ERR_WRONG_PERMISSION;
     }
 
     VAddr target_address = address;

src/core/hle/kernel/shared_memory.h

@@ -15,8 +15,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 /// Permissions for mapped shared memory blocks
 enum class MemoryPermission : u32 {
     None = 0,
@@ -34,7 +32,6 @@ class SharedMemory final : public Object {
 public:
     /**
      * Creates a shared memory object.
-     * @param kernel The kernel instance to create a shared memory instance under.
      * @param owner_process Process that created this shared memory object.
      * @param size Size of the memory block. Must be page-aligned.
      * @param permissions Permission restrictions applied to the process which created the block.
@@ -45,15 +42,14 @@ public:
      * linear heap.
      * @param name Optional object name, used for debugging purposes.
      */
-    static SharedPtr<SharedMemory> Create(KernelCore& kernel, SharedPtr<Process> owner_process,
-                                          u64 size, MemoryPermission permissions,
+    static SharedPtr<SharedMemory> Create(SharedPtr<Process> owner_process, u64 size,
+                                          MemoryPermission permissions,
                                           MemoryPermission other_permissions, VAddr address = 0,
                                           MemoryRegion region = MemoryRegion::BASE,
                                           std::string name = "Unknown");
 
     /**
      * Creates a shared memory object from a block of memory managed by an HLE applet.
-     * @param kernel The kernel instance to create a shared memory instance under.
      * @param heap_block Heap block of the HLE applet.
      * @param offset The offset into the heap block that the SharedMemory will map.
      * @param size Size of the memory block. Must be page-aligned.
@@ -62,8 +58,7 @@ public:
      * block.
      * @param name Optional object name, used for debugging purposes.
      */
-    static SharedPtr<SharedMemory> CreateForApplet(KernelCore& kernel,
-                                                   std::shared_ptr<std::vector<u8>> heap_block,
+    static SharedPtr<SharedMemory> CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
                                                    u32 offset, u32 size,
                                                    MemoryPermission permissions,
                                                    MemoryPermission other_permissions,
@@ -130,7 +125,7 @@ public:
     std::string name;
 
 private:
-    explicit SharedMemory(KernelCore& kernel);
+    SharedMemory();
     ~SharedMemory() override;
 };
 

src/core/hle/kernel/svc.cpp

@@ -12,20 +12,16 @@
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/string_util.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/svc_wrap.h"
@@ -91,15 +87,13 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
     CASCADE_RESULT(client_session, client_port->Connect());
 
     // Return the client session
-    auto& kernel = Core::System::GetInstance().Kernel();
-    CASCADE_RESULT(*out_handle, kernel.HandleTable().Create(client_session));
+    CASCADE_RESULT(*out_handle, g_handle_table.Create(client_session));
     return RESULT_SUCCESS;
 }
 
 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<ClientSession> session = kernel.HandleTable().Get<ClientSession>(handle);
+    SharedPtr<ClientSession> session = g_handle_table.Get<ClientSession>(handle);
     if (!session) {
         LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -118,8 +112,7 @@ static ResultCode SendSyncRequest(Handle handle) {
 static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -132,8 +125,7 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
     LOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    const SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
     if (!process) {
         return ERR_INVALID_HANDLE;
     }
@@ -176,11 +168,10 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 
     using ObjectPtr = SharedPtr<WaitObject>;
     std::vector<ObjectPtr> objects(handle_count);
-    auto& kernel = Core::System::GetInstance().Kernel();
 
     for (u64 i = 0; i < handle_count; ++i) {
         const Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
-        const auto object = kernel.HandleTable().Get<WaitObject>(handle);
+        const auto object = g_handle_table.Get<WaitObject>(handle);
 
         if (object == nullptr) {
             return ERR_INVALID_HANDLE;
@@ -228,8 +219,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 static ResultCode CancelSynchronization(Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -249,9 +239,7 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
               "requesting_current_thread_handle=0x{:08X}",
               holding_thread_handle, mutex_addr, requesting_thread_handle);
 
-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-    return Mutex::TryAcquire(handle_table, mutex_addr, holding_thread_handle,
-                             requesting_thread_handle);
+    return Mutex::TryAcquire(mutex_addr, holding_thread_handle, requesting_thread_handle);
 }
 
 /// Unlock a mutex
@@ -331,7 +319,8 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         *result = Core::CurrentProcess()->is_virtual_address_memory_enabled;
         break;
     case GetInfoType::TitleId:
-        *result = Core::CurrentProcess()->program_id;
+        LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query titleid, returned 0");
+        *result = 0;
         break;
     case GetInfoType::PrivilegedProcessId:
         LOG_WARNING(Kernel_SVC,
@@ -364,8 +353,7 @@ static ResultCode GetThreadContext(Handle handle, VAddr addr) {
 
 /// Gets the priority for the specified thread
 static ResultCode GetThreadPriority(u32* priority, Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(handle);
     if (!thread)
         return ERR_INVALID_HANDLE;
 
@@ -379,8 +367,7 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
         return ERR_OUT_OF_RANGE;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    SharedPtr<Thread> thread = g_handle_table.Get<Thread>(handle);
     if (!thread)
         return ERR_INVALID_HANDLE;
 
@@ -409,8 +396,7 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
               "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               shared_memory_handle, addr, size, permissions);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
     if (!shared_memory) {
         return ERR_INVALID_HANDLE;
     }
@@ -438,8 +424,7 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
     LOG_WARNING(Kernel_SVC, "called, shared_memory_handle=0x{:08X}, addr=0x{:X}, size=0x{:X}",
                 shared_memory_handle, addr, size);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
 
     return shared_memory->Unmap(Core::CurrentProcess().get(), addr);
 }
@@ -447,9 +432,7 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                      Handle process_handle, u64 addr) {
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
     if (!process) {
         return ERR_INVALID_HANDLE;
     }
@@ -546,11 +529,10 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
         break;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     CASCADE_RESULT(SharedPtr<Thread> thread,
-                   Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
+                   Thread::Create(name, entry_point, priority, arg, processor_id, stack_top,
                                   Core::CurrentProcess()));
-    CASCADE_RESULT(thread->guest_handle, kernel.HandleTable().Create(thread));
+    CASCADE_RESULT(thread->guest_handle, g_handle_table.Create(thread));
     *out_handle = thread->guest_handle;
 
     Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
@@ -567,8 +549,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 static ResultCode StartThread(Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -615,8 +596,7 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
         "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
         mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     ASSERT(thread);
 
     CASCADE_CODE(Mutex::Release(mutex_addr));
@@ -725,9 +705,8 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
                                                mutex_val | Mutex::MutexHasWaitersFlag));
 
             // The mutex is already owned by some other thread, make this thread wait on it.
-            auto& kernel = Core::System::GetInstance().Kernel();
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
-            auto owner = kernel.HandleTable().Get<Thread>(owner_handle);
+            auto owner = g_handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
             ASSERT(thread->status == ThreadStatus::WaitMutex);
             thread->wakeup_callback = nullptr;
@@ -805,20 +784,14 @@ static u64 GetSystemTick() {
 /// Close a handle
 static ResultCode CloseHandle(Handle handle) {
     LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    return kernel.HandleTable().Close(handle);
+    return g_handle_table.Close(handle);
 }
 
 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
     LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto event = kernel.HandleTable().Get<Event>(handle);
-
+    auto event = g_handle_table.Get<Event>(handle);
     ASSERT(event != nullptr);
-
     event->Clear();
     return RESULT_SUCCESS;
 }
@@ -834,8 +807,7 @@ static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32
 static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask) {
     LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -850,8 +822,7 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
     LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:16X}, core=0x{:X}", thread_handle,
               mask, core);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -891,23 +862,19 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
                                      u32 remote_permissions) {
     LOG_TRACE(Kernel_SVC, "called, size=0x{:X}, localPerms=0x{:08X}, remotePerms=0x{:08X}", size,
               local_permissions, remote_permissions);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto& handle_table = kernel.HandleTable();
-    auto shared_mem_handle =
-        SharedMemory::Create(kernel, handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
+    auto sharedMemHandle =
+        SharedMemory::Create(g_handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
                              static_cast<MemoryPermission>(local_permissions),
                              static_cast<MemoryPermission>(remote_permissions));
 
-    CASCADE_RESULT(*handle, handle_table.Create(shared_mem_handle));
+    CASCADE_RESULT(*handle, g_handle_table.Create(sharedMemHandle));
     return RESULT_SUCCESS;
 }
 
 static ResultCode ClearEvent(Handle handle) {
     LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Event> evt = kernel.HandleTable().Get<Event>(handle);
+    SharedPtr<Event> evt = g_handle_table.Get<Event>(handle);
     if (evt == nullptr)
         return ERR_INVALID_HANDLE;
     evt->Clear();

src/core/hle/kernel/thread.cpp

@@ -16,21 +16,22 @@
 #include "common/thread_queue_list.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
+#include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
 
 namespace Kernel {
 
+/// Event type for the thread wake up event
+static CoreTiming::EventType* ThreadWakeupEventType = nullptr;
+
 bool Thread::ShouldWait(Thread* thread) const {
     return status != ThreadStatus::Dead;
 }
@@ -39,17 +40,32 @@ void Thread::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
 }
 
-Thread::Thread(KernelCore& kernel) : WaitObject{kernel} {}
-Thread::~Thread() = default;
+// TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future, allowing
+//               us to simply use a pool index or similar.
+static Kernel::HandleTable wakeup_callback_handle_table;
+
+// The first available thread id at startup
+static u32 next_thread_id;
+
+/**
+ * Creates a new thread ID
+ * @return The new thread ID
+ */
+inline static u32 const NewThreadId() {
+    return next_thread_id++;
+}
+
+Thread::Thread() {}
+Thread::~Thread() {}
 
 void Thread::Stop() {
     // Cancel any outstanding wakeup events for this thread
-    CoreTiming::UnscheduleEvent(kernel.ThreadWakeupCallbackEventType(), callback_handle);
-    kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
+    CoreTiming::UnscheduleEvent(ThreadWakeupEventType, callback_handle);
+    wakeup_callback_handle_table.Close(callback_handle);
     callback_handle = 0;
 
     // Clean up thread from ready queue
-    // This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
+    // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
     if (status == ThreadStatus::Ready) {
         scheduler->UnscheduleThread(this, current_priority);
     }
@@ -82,6 +98,63 @@ void ExitCurrentThread() {
     Core::System::GetInstance().CurrentScheduler().RemoveThread(thread);
 }
 
+/**
+ * Callback that will wake up the thread it was scheduled for
+ * @param thread_handle The handle of the thread that's been awoken
+ * @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
+ */
+static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
+    const auto proper_handle = static_cast<Handle>(thread_handle);
+
+    // Lock the global kernel mutex when we enter the kernel HLE.
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+
+    SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>(proper_handle);
+    if (thread == nullptr) {
+        LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
+        return;
+    }
+
+    bool resume = true;
+
+    if (thread->status == ThreadStatus::WaitSynchAny ||
+        thread->status == ThreadStatus::WaitSynchAll ||
+        thread->status == ThreadStatus::WaitHLEEvent) {
+        // Remove the thread from each of its waiting objects' waitlists
+        for (auto& object : thread->wait_objects)
+            object->RemoveWaitingThread(thread.get());
+        thread->wait_objects.clear();
+
+        // Invoke the wakeup callback before clearing the wait objects
+        if (thread->wakeup_callback)
+            resume = thread->wakeup_callback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
+    }
+
+    if (thread->mutex_wait_address != 0 || thread->condvar_wait_address != 0 ||
+        thread->wait_handle) {
+        ASSERT(thread->status == ThreadStatus::WaitMutex);
+        thread->mutex_wait_address = 0;
+        thread->condvar_wait_address = 0;
+        thread->wait_handle = 0;
+
+        auto lock_owner = thread->lock_owner;
+        // Threads waking up by timeout from WaitProcessWideKey do not perform priority inheritance
+        // and don't have a lock owner unless SignalProcessWideKey was called first and the thread
+        // wasn't awakened due to the mutex already being acquired.
+        if (lock_owner) {
+            lock_owner->RemoveMutexWaiter(thread);
+        }
+    }
+
+    if (thread->arb_wait_address != 0) {
+        ASSERT(thread->status == ThreadStatus::WaitArb);
+        thread->arb_wait_address = 0;
+    }
+
+    if (resume)
+        thread->ResumeFromWait();
+}
+
 void Thread::WakeAfterDelay(s64 nanoseconds) {
     // Don't schedule a wakeup if the thread wants to wait forever
     if (nanoseconds == -1)
@@ -89,12 +162,12 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
 
     // This function might be called from any thread so we have to be cautious and use the
     // thread-safe version of ScheduleEvent.
-    CoreTiming::ScheduleEventThreadsafe(CoreTiming::nsToCycles(nanoseconds),
-                                        kernel.ThreadWakeupCallbackEventType(), callback_handle);
+    CoreTiming::ScheduleEventThreadsafe(CoreTiming::nsToCycles(nanoseconds), ThreadWakeupEventType,
+                                        callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {
-    CoreTiming::UnscheduleEventThreadsafe(kernel.ThreadWakeupCallbackEventType(), callback_handle);
+    CoreTiming::UnscheduleEventThreadsafe(ThreadWakeupEventType, callback_handle);
 }
 
 static boost::optional<s32> GetNextProcessorId(u64 mask) {
@@ -210,9 +283,9 @@ static std::tuple<std::size_t, std::size_t, bool> GetFreeThreadLocalSlot(
  * @param entry_point Address of entry point for execution
  * @param arg User argument for thread
  */
-static void ResetThreadContext(Core::ARM_Interface::ThreadContext& context, VAddr stack_top,
+static void ResetThreadContext(ARM_Interface::ThreadContext& context, VAddr stack_top,
                                VAddr entry_point, u64 arg) {
-    memset(&context, 0, sizeof(Core::ARM_Interface::ThreadContext));
+    memset(&context, 0, sizeof(ARM_Interface::ThreadContext));
 
     context.cpu_registers[0] = arg;
     context.pc = entry_point;
@@ -221,9 +294,9 @@ static void ResetThreadContext(Core::ARM_Interface::ThreadContext& context, VAdd
     context.fpscr = 0;
 }
 
-ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name, VAddr entry_point,
-                                            u32 priority, u64 arg, s32 processor_id,
-                                            VAddr stack_top, SharedPtr<Process> owner_process) {
+ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point, u32 priority,
+                                            u64 arg, s32 processor_id, VAddr stack_top,
+                                            SharedPtr<Process> owner_process) {
     // Check if priority is in ranged. Lowest priority -> highest priority id.
     if (priority > THREADPRIO_LOWEST) {
         LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
@@ -243,9 +316,9 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
         return ResultCode(-1);
     }
 
-    SharedPtr<Thread> thread(new Thread(kernel));
+    SharedPtr<Thread> thread(new Thread);
 
-    thread->thread_id = kernel.CreateNewThreadID();
+    thread->thread_id = NewThreadId();
     thread->status = ThreadStatus::Dormant;
     thread->entry_point = entry_point;
     thread->stack_top = stack_top;
@@ -260,7 +333,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->condvar_wait_address = 0;
     thread->wait_handle = 0;
     thread->name = std::move(name);
-    thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
+    thread->callback_handle = wakeup_callback_handle_table.Create(thread).Unwrap();
     thread->owner_process = owner_process;
     thread->scheduler = Core::System::GetInstance().Scheduler(processor_id);
     thread->scheduler->AddThread(thread, priority);
@@ -310,19 +383,19 @@ void Thread::BoostPriority(u32 priority) {
     current_priority = priority;
 }
 
-SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 priority,
+SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
                                   SharedPtr<Process> owner_process) {
     // Setup page table so we can write to memory
     SetCurrentPageTable(&Core::CurrentProcess()->vm_manager.page_table);
 
     // Initialize new "main" thread
-    auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0, THREADPROCESSORID_0,
+    auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
                                      Memory::STACK_AREA_VADDR_END, std::move(owner_process));
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
-    thread->guest_handle = kernel.HandleTable().Create(thread).Unwrap();
+    thread->guest_handle = Kernel::g_handle_table.Create(thread).Unwrap();
 
     thread->context.cpu_registers[1] = thread->guest_handle;
 
@@ -455,4 +528,13 @@ Thread* GetCurrentThread() {
     return Core::System::GetInstance().CurrentScheduler().GetCurrentThread();
 }
 
+void ThreadingInit() {
+    ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
+    next_thread_id = 1;
+}
+
+void ThreadingShutdown() {
+    Kernel::ClearProcessList();
+}
+
 } // namespace Kernel

src/core/hle/kernel/thread.h

@@ -56,7 +56,6 @@ enum class ThreadWakeupReason {
 
 namespace Kernel {
 
-class KernelCore;
 class Process;
 class Scheduler;
 
@@ -64,7 +63,6 @@ class Thread final : public WaitObject {
 public:
     /**
      * Creates and returns a new thread. The new thread is immediately scheduled
-     * @param kernel The kernel instance this thread will be created under.
      * @param name The friendly name desired for the thread
      * @param entry_point The address at which the thread should start execution
      * @param priority The thread's priority
@@ -74,9 +72,8 @@ public:
      * @param owner_process The parent process for the thread
      * @return A shared pointer to the newly created thread
      */
-    static ResultVal<SharedPtr<Thread>> Create(KernelCore& kernel, std::string name,
-                                               VAddr entry_point, u32 priority, u64 arg,
-                                               s32 processor_id, VAddr stack_top,
+    static ResultVal<SharedPtr<Thread>> Create(std::string name, VAddr entry_point, u32 priority,
+                                               u64 arg, s32 processor_id, VAddr stack_top,
                                                SharedPtr<Process> owner_process);
 
     std::string GetName() const override {
@@ -207,7 +204,7 @@ public:
         return status == ThreadStatus::WaitSynchAll;
     }
 
-    Core::ARM_Interface::ThreadContext context;
+    ARM_Interface::ThreadContext context;
 
     u32 thread_id;
 
@@ -266,7 +263,7 @@ public:
     u64 affinity_mask{0x1};
 
 private:
-    explicit Thread(KernelCore& kernel);
+    Thread();
     ~Thread() override;
 
     std::shared_ptr<std::vector<u8>> tls_memory = std::make_shared<std::vector<u8>>();
@@ -274,13 +271,12 @@ private:
 
 /**
  * Sets up the primary application 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
  * @param owner_process The parent process for the main thread
  * @return A shared pointer to the main thread
  */
-SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 priority,
+SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
                                   SharedPtr<Process> owner_process);
 
 /**
@@ -298,4 +294,14 @@ void WaitCurrentThread_Sleep();
  */
 void ExitCurrentThread();
 
+/**
+ * Initialize threading
+ */
+void ThreadingInit();
+
+/**
+ * Shutdown threading
+ */
+void ThreadingShutdown();
+
 } // namespace Kernel

src/core/hle/kernel/timer.cpp

@@ -2,31 +2,36 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cinttypes>
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
 
 namespace Kernel {
 
-Timer::Timer(KernelCore& kernel) : WaitObject{kernel} {}
-Timer::~Timer() = default;
+/// The event type of the generic timer callback event
+static CoreTiming::EventType* timer_callback_event_type = nullptr;
+// TODO(yuriks): This can be removed if Timer objects are explicitly pooled in the future, allowing
+//               us to simply use a pool index or similar.
+static Kernel::HandleTable timer_callback_handle_table;
 
-SharedPtr<Timer> Timer::Create(KernelCore& kernel, ResetType reset_type, std::string name) {
-    SharedPtr<Timer> timer(new Timer(kernel));
+Timer::Timer() {}
+Timer::~Timer() {}
+
+SharedPtr<Timer> Timer::Create(ResetType reset_type, std::string name) {
+    SharedPtr<Timer> timer(new Timer);
 
     timer->reset_type = reset_type;
     timer->signaled = false;
     timer->name = std::move(name);
     timer->initial_delay = 0;
     timer->interval_delay = 0;
-    timer->callback_handle = kernel.CreateTimerCallbackHandle(timer).Unwrap();
+    timer->callback_handle = timer_callback_handle_table.Create(timer).Unwrap();
 
     return timer;
 }
@@ -53,13 +58,13 @@ void Timer::Set(s64 initial, s64 interval) {
         // Immediately invoke the callback
         Signal(0);
     } else {
-        CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(initial), kernel.TimerCallbackEventType(),
+        CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(initial), timer_callback_event_type,
                                   callback_handle);
     }
 }
 
 void Timer::Cancel() {
-    CoreTiming::UnscheduleEvent(kernel.TimerCallbackEventType(), callback_handle);
+    CoreTiming::UnscheduleEvent(timer_callback_event_type, callback_handle);
 }
 
 void Timer::Clear() {
@@ -84,8 +89,28 @@ void Timer::Signal(int cycles_late) {
     if (interval_delay != 0) {
         // Reschedule the timer with the interval delay
         CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(interval_delay) - cycles_late,
-                                  kernel.TimerCallbackEventType(), callback_handle);
+                                  timer_callback_event_type, callback_handle);
     }
 }
 
+/// The timer callback event, called when a timer is fired
+static void TimerCallback(u64 timer_handle, int cycles_late) {
+    SharedPtr<Timer> timer =
+        timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle));
+
+    if (timer == nullptr) {
+        LOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
+        return;
+    }
+
+    timer->Signal(cycles_late);
+}
+
+void TimersInit() {
+    timer_callback_handle_table.Clear();
+    timer_callback_event_type = CoreTiming::RegisterEvent("TimerCallback", TimerCallback);
+}
+
+void TimersShutdown() {}
+
 } // namespace Kernel

src/core/hle/kernel/timer.h

@@ -10,19 +10,15 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 class Timer final : public WaitObject {
 public:
     /**
      * Creates a timer
-     * @param kernel The kernel instance to create the timer callback handle for.
      * @param reset_type ResetType describing how to create the timer
      * @param name Optional name of timer
      * @return The created Timer
      */
-    static SharedPtr<Timer> Create(KernelCore& kernel, ResetType reset_type,
-                                   std::string name = "Unknown");
+    static SharedPtr<Timer> Create(ResetType reset_type, std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "Timer";
@@ -72,7 +68,7 @@ public:
     void Signal(int cycles_late);
 
 private:
-    explicit Timer(KernelCore& kernel);
+    Timer();
     ~Timer() override;
 
     ResetType reset_type; ///< The ResetType of this timer
@@ -87,4 +83,9 @@ private:
     Handle callback_handle;
 };
 
+/// Initializes the required variables for timers
+void TimersInit();
+/// Tears down the timer variables
+void TimersShutdown();
+
 } // namespace Kernel

src/core/hle/kernel/wait_object.cpp

@@ -12,9 +12,6 @@
 
 namespace Kernel {
 
-WaitObject::WaitObject(KernelCore& kernel) : Object{kernel} {}
-WaitObject::~WaitObject() = default;
-
 void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) {
     auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
     if (itr == waiting_threads.end())

src/core/hle/kernel/wait_object.h

@@ -11,15 +11,11 @@
 
 namespace Kernel {
 
-class KernelCore;
 class Thread;
 
 /// Class that represents a Kernel object that a thread can be waiting on
 class WaitObject : public Object {
 public:
-    explicit WaitObject(KernelCore& kernel);
-    ~WaitObject() override;
-
     /**
      * Check if the specified thread should wait until the object is available
      * @param thread The thread about which we're deciding.

src/core/hle/result.h

@@ -227,7 +227,7 @@ public:
         }
     }
 
-    ResultVal(ResultVal&& o) noexcept : result_code(o.result_code) {
+    ResultVal(ResultVal&& o) : result_code(o.result_code) {
         if (!o.empty()) {
             new (&object) T(std::move(o.object));
         }

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

@@ -3,19 +3,17 @@
 // Refer to the license.txt file included.
 
 #include <array>
-#include "common/common_types.h"
 #include "common/logging/log.h"
-#include "common/swap.h"
-#include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/acc/acc.h"
 #include "core/hle/service/acc/acc_aa.h"
 #include "core/hle/service/acc/acc_su.h"
 #include "core/hle/service/acc/acc_u0.h"
 #include "core/hle/service/acc/acc_u1.h"
-#include "core/hle/service/acc/profile_manager.h"
+#include "core/settings.h"
 
 namespace Service::Account {
+
 // TODO: RE this structure
 struct UserData {
     INSERT_PADDING_WORDS(1);
@@ -27,10 +25,19 @@ struct UserData {
 };
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
 
+struct ProfileBase {
+    u128 user_id;
+    u64 timestamp;
+    std::array<u8, 0x20> username;
+};
+static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase structure has incorrect size");
+
+// TODO(ogniK): Generate a real user id based on username, md5(username) maybe?
+static constexpr u128 DEFAULT_USER_ID{1ull, 0ull};
+
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
-        : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
+    explicit IProfile(u128 user_id) : ServiceFramework("IProfile"), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
             {1, &IProfile::GetBase, "GetBase"},
@@ -42,42 +49,46 @@ public:
 
 private:
     void Get(Kernel::HLERequestContext& ctx) {
-        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
         ProfileBase profile_base{};
-        std::array<u8, MAX_DATA> data{};
-        if (profile_manager.GetProfileBaseAndData(user_id, profile_base, data)) {
-            ctx.WriteBuffer(data);
-            IPC::ResponseBuilder rb{ctx, 16};
-            rb.Push(RESULT_SUCCESS);
-            rb.PushRaw(profile_base);
+        profile_base.user_id = user_id;
+        if (Settings::values.username.size() > profile_base.username.size()) {
+            std::copy_n(Settings::values.username.begin(), profile_base.username.size(),
+                        profile_base.username.begin());
         } else {
-            LOG_ERROR(Service_ACC, "Failed to get profile base and data for user={}",
-                      user_id.Format());
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(-1)); // TODO(ogniK): Get actual error code
+            std::copy(Settings::values.username.begin(), Settings::values.username.end(),
+                      profile_base.username.begin());
         }
+
+        IPC::ResponseBuilder rb{ctx, 16};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw(profile_base);
     }
 
     void GetBase(Kernel::HLERequestContext& ctx) {
-        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+
+        // TODO(Subv): Retrieve this information from somewhere.
         ProfileBase profile_base{};
-        if (profile_manager.GetProfileBase(user_id, profile_base)) {
-            IPC::ResponseBuilder rb{ctx, 16};
-            rb.Push(RESULT_SUCCESS);
-            rb.PushRaw(profile_base);
+        profile_base.user_id = user_id;
+        if (Settings::values.username.size() > profile_base.username.size()) {
+            std::copy_n(Settings::values.username.begin(), profile_base.username.size(),
+                        profile_base.username.begin());
         } else {
-            LOG_ERROR(Service_ACC, "Failed to get profile base for user={}", user_id.Format());
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultCode(-1)); // TODO(ogniK): Get actual error code
+            std::copy(Settings::values.username.begin(), Settings::values.username.end(),
+                      profile_base.username.begin());
         }
+        IPC::ResponseBuilder rb{ctx, 16};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw(profile_base);
     }
 
     void LoadImage(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
         // smallest jpeg https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
         // TODO(mailwl): load actual profile image from disk, width 256px, max size 0x20000
-        constexpr u32 jpeg_size = 107;
-        static constexpr std::array<u8, jpeg_size> jpeg{
+        const u32 jpeg_size = 107;
+        static const std::array<u8, jpeg_size> jpeg{
             0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
             0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04,
             0x08, 0x06, 0x06, 0x05, 0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a,
@@ -87,14 +98,13 @@ private:
             0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
             0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
         };
-        ctx.WriteBuffer(jpeg);
+        ctx.WriteBuffer(jpeg.data(), jpeg_size);
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(jpeg_size);
     }
 
-    const ProfileManager& profile_manager;
-    UUID user_id; ///< The user id this profile refers to.
+    u128 user_id; ///< The user id this profile refers to.
 };
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
@@ -131,57 +141,44 @@ private:
 };
 
 void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_ACC, "called");
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(static_cast<u32>(profile_manager->GetUserCount()));
+    rb.Push<u32>(1);
 }
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    UUID user_id = rp.PopRaw<UUID>();
-    LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
-
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(profile_manager->UserExists(user_id));
+    rb.Push(true); // TODO: Check when this is supposed to return true and when not
 }
 
 void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_ACC, "called");
-    ctx.WriteBuffer(profile_manager->GetAllUsers());
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    // TODO(Subv): There is only one user for now.
+    const std::vector<u128> user_ids = {DEFAULT_USER_ID};
+    ctx.WriteBuffer(user_ids);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void Module::Interface::ListOpenUsers(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_ACC, "called");
-    ctx.WriteBuffer(profile_manager->GetOpenUsers());
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    // TODO(Subv): There is only one user for now.
+    const std::vector<u128> user_ids = {DEFAULT_USER_ID};
+    ctx.WriteBuffer(user_ids);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
-void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_ACC, "called");
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushRaw<UUID>(profile_manager->GetLastOpenedUser());
-}
-
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    UUID user_id = rp.PopRaw<UUID>();
+    u128 user_id = rp.PopRaw<u128>();
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IProfile>(user_id, *profile_manager);
-    LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
-}
-
-void Module::Interface::IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(profile_manager->CanSystemRegisterUser());
+    rb.PushIpcInterface<IProfile>(user_id);
+    LOG_DEBUG(Service_ACC, "called user_id=0x{:016X}{:016X}", user_id[1], user_id[0]);
 }
 
 void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
@@ -197,20 +194,22 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
     LOG_DEBUG(Service_ACC, "called");
 }
 
-Module::Interface::Interface(std::shared_ptr<Module> module,
-                             std::shared_ptr<ProfileManager> profile_manager, const char* name)
-    : ServiceFramework(name), module(std::move(module)),
-      profile_manager(std::move(profile_manager)) {}
+void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw(DEFAULT_USER_ID);
+}
 
-Module::Interface::~Interface() = default;
+Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
+    : ServiceFramework(name), module(std::move(module)) {}
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
-    auto profile_manager = std::make_shared<ProfileManager>();
-    std::make_shared<ACC_AA>(module, profile_manager)->InstallAsService(service_manager);
-    std::make_shared<ACC_SU>(module, profile_manager)->InstallAsService(service_manager);
-    std::make_shared<ACC_U0>(module, profile_manager)->InstallAsService(service_manager);
-    std::make_shared<ACC_U1>(module, profile_manager)->InstallAsService(service_manager);
+    std::make_shared<ACC_AA>(module)->InstallAsService(service_manager);
+    std::make_shared<ACC_SU>(module)->InstallAsService(service_manager);
+    std::make_shared<ACC_U0>(module)->InstallAsService(service_manager);
+    std::make_shared<ACC_U1>(module)->InstallAsService(service_manager);
 }
 
 } // namespace Service::Account

src/core/hle/service/acc/acc.h

@@ -8,15 +8,11 @@
 
 namespace Service::Account {
 
-class ProfileManager;
-
 class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        explicit Interface(std::shared_ptr<Module> module,
-                           std::shared_ptr<ProfileManager> profile_manager, const char* name);
-        ~Interface() override;
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
 
         void GetUserCount(Kernel::HLERequestContext& ctx);
         void GetUserExistence(Kernel::HLERequestContext& ctx);
@@ -26,11 +22,9 @@ public:
         void GetProfile(Kernel::HLERequestContext& ctx);
         void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
         void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);
-        void IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;
-        std::shared_ptr<ProfileManager> profile_manager;
     };
 };
 

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

@@ -6,8 +6,7 @@
 
 namespace Service::Account {
 
-ACC_AA::ACC_AA(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
-    : Module::Interface(std::move(module), std::move(profile_manager), "acc:aa") {
+ACC_AA::ACC_AA(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:aa") {
     static const FunctionInfo functions[] = {
         {0, nullptr, "EnsureCacheAsync"},
         {1, nullptr, "LoadCache"},

src/core/hle/service/acc/acc_aa.h

@@ -10,8 +10,7 @@ namespace Service::Account {
 
 class ACC_AA final : public Module::Interface {
 public:
-    explicit ACC_AA(std::shared_ptr<Module> module,
-                    std::shared_ptr<ProfileManager> profile_manager);
+    explicit ACC_AA(std::shared_ptr<Module> module);
 };
 
 } // namespace Service::Account

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

@@ -6,8 +6,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") {
+ACC_SU::ACC_SU(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:su") {
     static const FunctionInfo functions[] = {
         {0, &ACC_SU::GetUserCount, "GetUserCount"},
         {1, &ACC_SU::GetUserExistence, "GetUserExistence"},
@@ -16,7 +15,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {4, &ACC_SU::GetLastOpenedUser, "GetLastOpenedUser"},
         {5, &ACC_SU::GetProfile, "GetProfile"},
         {6, nullptr, "GetProfileDigest"},
-        {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
+        {50, nullptr, "IsUserRegistrationRequestPermitted"},
         {51, nullptr, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
         {100, nullptr, "GetUserRegistrationNotifier"},