"Merge Tagged PR 1012"

"Merge Tagged PR 1340"
"Merge Tagged PR 1703"
2019-10-03 12:01:21 +00:00 · 2019-10-03 12:01:20 +00:00 · 2019-10-03 12:01:19 +00:00 · 2019-10-03 12:01:18 +00:00 · 2019-10-03 12:01:17 +00:00 · 2019-10-03 12:01:16 +00:00
152 changed files with 1169 additions and 4708 deletions
@@ -5,11 +5,10 @@ cd /yuzu
 ccache -s

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
+cmake .. -G Ninja -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON

 ninja

 ccache -s

-# Ignore zlib's tests, since they aren't gated behind a CMake option.
-ctest -VV -E "(example|example64)" -C Release
+ctest -VV -C Release
@@ -2,4 +2,4 @@

 mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/linux/docker.sh
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh $1
+docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh
@@ -13,7 +13,7 @@ echo '' >> /bin/cmd
 chmod +x /bin/cmd

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja

 # Clean up the dirty hacks
@@ -2,4 +2,4 @@

 mkdir -p "ccache" || true
 chmod a+x ./.ci/scripts/windows/docker.sh
-docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh $1
+docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh
@@ -5,8 +5,6 @@ $RELEASE_DIST = "yuzu-windows-msvc"
 $MSVC_BUILD_ZIP = "yuzu-windows-msvc-$GITDATE-$GITREV.zip" -replace " ", ""
 $MSVC_BUILD_PDB = "yuzu-windows-msvc-$GITDATE-$GITREV-debugsymbols.zip" -replace " ", ""
 $MSVC_SEVENZIP = "yuzu-windows-msvc-$GITDATE-$GITREV.7z" -replace " ", ""
-$MSVC_TAR = "yuzu-windows-msvc-$GITDATE-$GITREV.tar" -replace " ", ""
-$MSVC_TARXZ = "yuzu-windows-msvc-$GITDATE-$GITREV.tar.xz" -replace " ", ""

 $env:BUILD_ZIP = $MSVC_BUILD_ZIP
 $env:BUILD_SYMBOLS = $MSVC_BUILD_PDB
@@ -30,9 +28,5 @@ Copy-Item .\README.md -Destination $RELEASE_DIST
 7z a -tzip $MSVC_BUILD_ZIP $RELEASE_DIST\*
 7z a $MSVC_SEVENZIP $RELEASE_DIST

-7z a -r -ttar $MSVC_TAR $RELEASE_DIST
-7z a -r -txz $MSVC_TARXZ $MSVC_TAR
-
 Get-ChildItem . -Filter "*.zip" | Copy-Item -destination "artifacts"
-Get-ChildItem . -Filter "*.7z" | Copy-Item -destination "artifacts"
-Get-ChildItem . -Filter "*.tar.xz" | Copy-Item -destination "artifacts"
+Get-ChildItem . -Filter "*.7z" | Copy-Item -destination "artifacts"
@@ -1,5 +1,5 @@
 steps:
  - script: mkdir artifacts || echo 'X' > artifacts/T1.txt
  - publish: artifacts
-    artifact: 'yuzu-$(BuildName)-mock'
+    artifact: 'yuzu-$(BuildName)-$(BuildSuffix)'
    displayName: 'Upload Artifacts'
@@ -1,10 +1,9 @@
 parameters:
  artifactSource: 'true'
  cache: 'false'
-  version: ''

 steps:
- script: mkdir build && cd build && cmake -G "Visual Studio 15 2017 Win64" --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
+- script: mkdir build && cd build && set DATE=`date '+%Y.%m.%d'` && set CI=true && set AZURE_REPO_NAME=yuzu-emu/yuzu-$(BuildName) && set AZURE_REPO_TAG=$(BuildName)-$DATE && cmake -G "Visual Studio 15 2017 Win64" --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
@@ -1,7 +1,6 @@
 parameters:
  artifactSource: 'true'
  cache: 'false'
-  version: ''

 steps:
 - task: DockerInstaller@0
@@ -14,7 +13,7 @@ steps:
    key: yuzu-v1-$(BuildName)-$(BuildSuffix)-$(CacheSuffix)
    path: $(System.DefaultWorkingDirectory)/ccache
    cacheHitVar: CACHE_RESTORED
- script: chmod a+x ./.ci/scripts/$(ScriptFolder)/exec.sh && ./.ci/scripts/$(ScriptFolder)/exec.sh ${{ parameters['version'] }}
+- script: export DATE=`date '+%Y.%m.%d'` && export CI=true && export AZURE_REPO_NAME=yuzu-emu/yuzu-$(BuildName) && export AZURE_REPO_TAG=$(BuildName)-$DATE && chmod a+x ./.ci/scripts/$(ScriptFolder)/exec.sh && ./.ci/scripts/$(ScriptFolder)/exec.sh
  displayName: 'Build'
 - script: chmod a+x ./.ci/scripts/$(ScriptFolder)/upload.sh && RELEASE_NAME=$(BuildName) ./.ci/scripts/$(ScriptFolder)/upload.sh
  displayName: 'Package Artifacts'
@@ -1,6 +1,3 @@
-parameters:
-  version: ''
-
 jobs:
 - job: build
  displayName: 'standard'
@@ -23,5 +20,4 @@ jobs:
  - template: ./build-single.yml
    parameters:
      artifactSource: 'false'
-      cache: $(parameters.cache)
-      version: $(parameters.version)
+      cache: $(parameters.cache)
@@ -1,6 +1,3 @@
-parameters:
-  version: ''
-
 jobs:
 - job: build_test
  displayName: 'testing'
@@ -34,4 +31,3 @@ jobs:
      parameters:
        artifactSource: 'false'
        cache: 'false'
-        version: $(parameters.version)
@@ -31,7 +31,17 @@ jobs:
      needSubmodules: 'true'
  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
    displayName: 'Apply Git Configuration'
+  - script: git tag -a $(BuildName)-$(Build.BuildId) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName)"
+    displayName: 'Tag Source'
  - script: git remote add other $(GitRepoPushChangesURL)
    displayName: 'Register Repository'
-  - script: git push --force other HEAD:$(GitPushBranch)
+  - script: git push --follow-tags --force other HEAD:$(GitPushBranch)
    displayName: 'Update Code'
+  - script: git rev-list -n 1 $(BuildName)-$(Build.BuildId) > $(Build.ArtifactStagingDirectory)/tag-commit.sha
+    displayName: 'Calculate Release Point'
+  - task: PublishPipelineArtifact@1
+    displayName: 'Upload Release Point'
+    inputs:
+      targetPath: '$(Build.ArtifactStagingDirectory)/tag-commit.sha'
+      artifact: 'yuzu-$(BuildName)-release-point'
+      replaceExistingArchive: true
@@ -30,7 +30,17 @@ jobs:
      needSubmodules: 'true'
  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
    displayName: 'Apply Git Configuration'
+  - script: git tag -a $(BuildName)-$(Build.BuildId) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName)"
+    displayName: 'Tag Source'
  - script: git remote add other $(GitRepoPushChangesURL)
    displayName: 'Register Repository'
-  - script: git push --force other HEAD:$(GitPushBranch)
+  - script: git push --follow-tags --force other HEAD:$(GitPushBranch)
    displayName: 'Update Code'
+  - script: git rev-list -n 1 $(BuildName)-$(Build.BuildId) > $(Build.ArtifactStagingDirectory)/tag-commit.sha
+    displayName: 'Calculate Release Point'
+  - task: PublishPipelineArtifact@1
+    displayName: 'Upload Release Point'
+    inputs:
+      targetPath: '$(Build.ArtifactStagingDirectory)/tag-commit.sha'
+      artifact: 'yuzu-$(BuildName)-release-point'
+      replaceExistingArchive: true
@@ -1,13 +1,11 @@
 steps:
  - template: ./release-download.yml
  - task: GitHubRelease@0
-    displayName: 'GitHub Release'
    inputs:
      action: 'create'
-      title: '$(ReleasePrefix) $(DisplayVersion)'
+      title: 'yuzu $(BuildName) #$(Build.BuildId)'
      assets: '$(Build.ArtifactStagingDirectory)/*'
      gitHubConnection: $(GitHubReleaseConnectionName)
      repositoryName: '$(Build.Repository.Name)'
      target: '$(Build.SourceVersion)'
-      tagSource: manual
-      tag: $(BuildName)-$(DisplayPrefix)-$(DisplayVersion)
+      tagSource: 'auto'
@@ -1,9 +0,0 @@
-steps:
-  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
-    displayName: 'Apply Git Configuration'
-  - script: git tag -a $(BuildName)-$(DisplayPrefix)-$(DisplayVersion) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName) $(DisplayPrefix)-$(DisplayVersion)"
-    displayName: 'Tag Source'
-  - script: git remote add other $(GitRepoPushChangesURL)
-    displayName: 'Register Repository'
-  - script: git push other $(BuildName)-$(DisplayPrefix)-$(DisplayVersion)
-    displayName: 'Update Code'
@@ -1,9 +1,6 @@
 trigger:
 - master

-variables:
-  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]
-
 stages:
 - stage: format
  displayName: 'format'
@@ -37,7 +34,6 @@ stages:
      parameters:
        artifactSource: 'false'
        cache: 'true'
-        version: $(DisplayVersion)
 - stage: build_win
  dependsOn: format
  displayName: 'build-windows'
@@ -55,14 +51,13 @@ stages:
      parameters:
        artifactSource: 'false'
        cache: 'true'
-        version: $(DisplayVersion)
 - stage: release
-  displayName: 'release'
+  displayName: 'Release'
  dependsOn:
  - build
  - build_win
  jobs:
  - job: github
-    displayName: 'github'
+    displayName: 'GitHub Release'
    steps:
    - template: ./templates/release-github.yml
@@ -1,9 +1,6 @@
 trigger:
 - master

-variables:
-  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]
-
 stages:
 - stage: format
  displayName: 'format'
@@ -31,12 +28,3 @@ stages:
      parameters:
        artifactSource: 'false'
        cache: $(parameters.cache)
-        version: $(DisplayVersion)
- stage: release
-  displayName: 'release'
-  dependsOn: build
-  jobs:
-    - job: release
-      displayName: 'source'
-      steps:
-        - template: ./templates/release-private-tag.yml
@@ -47,8 +47,8 @@
    path = externals/sirit
    url = https://github.com/ReinUsesLisp/sirit
 [submodule "libzip"]
-    path = externals/libzip
-    url = https://github.com/DarkLordZach/libzip
+	path = externals/libzip
+	url = https://github.com/DarkLordZach/libzip
 [submodule "zlib"]
-    path = externals/zlib
-    url = https://github.com/madler/zlib
+	path = externals/zlib
+	url = https://github.com/DarkLordZach/zlib
@@ -83,15 +83,9 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/decode/video.cpp"
    "${VIDEO_CORE}/shader/decode/warp.cpp"
    "${VIDEO_CORE}/shader/decode/xmad.cpp"
-    "${VIDEO_CORE}/shader/ast.cpp"
-    "${VIDEO_CORE}/shader/ast.h"
    "${VIDEO_CORE}/shader/control_flow.cpp"
    "${VIDEO_CORE}/shader/control_flow.h"
-    "${VIDEO_CORE}/shader/compiler_settings.cpp"
-    "${VIDEO_CORE}/shader/compiler_settings.h"
    "${VIDEO_CORE}/shader/decode.cpp"
-    "${VIDEO_CORE}/shader/expr.cpp"
-    "${VIDEO_CORE}/shader/expr.h"
    "${VIDEO_CORE}/shader/node.h"
    "${VIDEO_CORE}/shader/node_helper.cpp"
    "${VIDEO_CORE}/shader/node_helper.h"
@@ -77,11 +77,11 @@ if (ENABLE_VULKAN)
    add_subdirectory(sirit)
 endif()

-# zlib
-add_subdirectory(zlib EXCLUDE_FROM_ALL)
-
 # libzip
-add_subdirectory(libzip EXCLUDE_FROM_ALL)
+add_subdirectory(libzip)
+
+# zlib
+add_subdirectory(zlib)

 if (ENABLE_WEB_SERVICE)
    # LibreSSL
@@ -341,24 +341,15 @@ Public License instead of this License.

 The icons used in this project have the following licenses:

-Icon Name                                   | License       | Origin/Author
---                                         | ---           | ---
-checked.png                                 | Free for non-commercial use
-failed.png                                  | Free for non-commercial use
-lock.png                                    | CC BY-ND 3.0  | https://icons8.com
-plus_folder.png (Default, Dark)             | CC BY-ND 3.0  | https://icons8.com
-bad_folder.png (Default, Dark)              | CC BY-ND 3.0  | https://icons8.com
-chip.png (Default, Dark)                    | CC BY-ND 3.0  | https://icons8.com
-folder.png (Default, Dark)                  | CC BY-ND 3.0  | https://icons8.com
-plus.png (Default, Dark)                    | CC0 1.0       | Designed by BreadFish64 from the Citra team
-sd_card.png (Default, Dark)                 | CC BY-ND 3.0  | https://icons8.com
-plus_folder.png (Colorful, Colorful Dark)   | CC BY-ND 3.0  | https://icons8.com
-bad_folder.png (Colorful, Colorful Dark)    | CC BY-ND 3.0  | https://icons8.com
-chip.png (Colorful, Colorful Dark)          | CC BY-ND 3.0  | https://icons8.com
-folder.png (Colorful, Colorful Dark)        | CC BY-ND 3.0  | https://icons8.com
-plus.png (Colorful, Colorful Dark)          | CC BY-ND 3.0  | https://icons8.com
-sd_card.png (Colorful, Colorful Dark)       | CC BY-ND 3.0  | https://icons8.com
-
-Note:
-Some icons are different in different themes, and they are separately listed
-only when they have different licenses/origins.
+Icon Name                          | License       | Origin/Author
+---                                | ---           | ---
+checked.png                        | Free for non-commercial use
+failed.png                         | Free for non-commercial use
+lock.png                           | CC BY-ND 3.0  | https://icons8.com
+plus_folder.png                    | CC BY-ND 3.0  | https://icons8.com
+bad_folder.png                     | CC BY-ND 3.0  | https://icons8.com
+chip.png                           | CC BY-ND 3.0  | https://icons8.com
+folder.png                         | CC BY-ND 3.0  | https://icons8.com
+plus.png (Default, Dark)           | CC0 1.0       | Designed by BreadFish64 from the Citra team
+plus.png (Colorful, Colorful Dark) | CC BY-ND 3.0  | https://icons8.com
+sd_card.png | CC BY-ND 3.0 | https://icons8.com
@@ -15,23 +15,11 @@ if (DEFINED ENV{CI})
    set(BUILD_TAG $ENV{AZURE_REPO_TAG})
  endif()
 endif()
-if (DEFINED ENV{TITLEBARFORMATIDLE})
-  set(TITLE_BAR_FORMAT_IDLE $ENV{TITLEBARFORMATIDLE})
-endif ()
-if (DEFINED ENV{TITLEBARFORMATRUNNING})
-  set(TITLE_BAR_FORMAT_RUNNING $ENV{TITLEBARFORMATRUNNING})
-endif ()
-if (DEFINED ENV{DISPLAYVERSION})
-  set(DISPLAY_VERSION $ENV{DISPLAYVERSION})
-endif ()
 add_custom_command(OUTPUT scm_rev.cpp
    COMMAND ${CMAKE_COMMAND}
      -DSRC_DIR="${CMAKE_SOURCE_DIR}"
      -DBUILD_REPOSITORY="${BUILD_REPOSITORY}"
-      -DTITLE_BAR_FORMAT_IDLE="${TITLE_BAR_FORMAT_IDLE}"
-      -DTITLE_BAR_FORMAT_RUNNING="${TITLE_BAR_FORMAT_RUNNING}"
      -DBUILD_TAG="${BUILD_TAG}"
-      -DBUILD_ID="${DISPLAY_VERSION}"
      -P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
    DEPENDS
      # WARNING! It was too much work to try and make a common location for this list,
@@ -72,15 +60,9 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/decode/video.cpp"
      "${VIDEO_CORE}/shader/decode/warp.cpp"
      "${VIDEO_CORE}/shader/decode/xmad.cpp"
-      "${VIDEO_CORE}/shader/ast.cpp"
-      "${VIDEO_CORE}/shader/ast.h"
      "${VIDEO_CORE}/shader/control_flow.cpp"
      "${VIDEO_CORE}/shader/control_flow.h"
-      "${VIDEO_CORE}/shader/compiler_settings.cpp"
-      "${VIDEO_CORE}/shader/compiler_settings.h"
      "${VIDEO_CORE}/shader/decode.cpp"
-      "${VIDEO_CORE}/shader/expr.cpp"
-      "${VIDEO_CORE}/shader/expr.h"
      "${VIDEO_CORE}/shader/node.h"
      "${VIDEO_CORE}/shader/node_helper.cpp"
      "${VIDEO_CORE}/shader/node_helper.h"
@@ -51,17 +51,7 @@ public:
    using reference = T&;
    using const_reference = const T&;

-    using propagate_on_container_copy_assignment = std::true_type;
-    using propagate_on_container_move_assignment = std::true_type;
-    using propagate_on_container_swap = std::true_type;
-    using is_always_equal = std::true_type;
-
 public:
-    constexpr AlignmentAllocator() noexcept = default;
-
-    template <typename T2>
-    constexpr AlignmentAllocator(const AlignmentAllocator<T2, Align>&) noexcept {}
-
    pointer address(reference r) noexcept {
        return std::addressof(r);
    }
@@ -36,7 +36,6 @@
 #define LOAD_DIR "load"
 #define DUMP_DIR "dump"
 #define SHADER_DIR "shader"
-#define RESCALING_DIR "rescaling"
 #define LOG_DIR "log"

 // Filenames
@@ -695,7 +695,6 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
        paths.emplace(UserPath::LoadDir, user_path + LOAD_DIR DIR_SEP);
        paths.emplace(UserPath::DumpDir, user_path + DUMP_DIR DIR_SEP);
        paths.emplace(UserPath::ShaderDir, user_path + SHADER_DIR DIR_SEP);
-        paths.emplace(UserPath::RescalingDir, user_path + RESCALING_DIR DIR_SEP);
        paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
        paths.emplace(UserPath::KeysDir, user_path + KEYS_DIR DIR_SEP);
        // TODO: Put the logs in a better location for each OS
@@ -714,6 +713,7 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
        case UserPath::RootDir:
            user_path = paths[UserPath::RootDir] + DIR_SEP;
            break;
+
        case UserPath::UserDir:
            user_path = paths[UserPath::RootDir] + DIR_SEP;
            paths[UserPath::ConfigDir] = user_path + CONFIG_DIR DIR_SEP;
@@ -721,8 +721,6 @@ const std::string& GetUserPath(UserPath path, const std::string& new_path) {
            paths[UserPath::SDMCDir] = user_path + SDMC_DIR DIR_SEP;
            paths[UserPath::NANDDir] = user_path + NAND_DIR DIR_SEP;
            break;
-        default:
-            break;
        }
    }

@@ -33,7 +33,6 @@ enum class UserPath {
    LoadDir,
    DumpDir,
    ShaderDir,
-    RescalingDir,
    SysDataDir,
    UserDir,
 };
@@ -11,9 +11,6 @@
 #define BUILD_DATE   "@BUILD_DATE@"
 #define BUILD_FULLNAME "@BUILD_FULLNAME@"
 #define BUILD_VERSION "@BUILD_VERSION@"
-#define BUILD_ID "@BUILD_ID@"
-#define TITLE_BAR_FORMAT_IDLE "@TITLE_BAR_FORMAT_IDLE@"
-#define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@"
 #define SHADER_CACHE_VERSION "@SHADER_CACHE_VERSION@"

 namespace Common {
@@ -25,9 +22,6 @@ const char g_build_name[]   = BUILD_NAME;
 const char g_build_date[]   = BUILD_DATE;
 const char g_build_fullname[] = BUILD_FULLNAME;
 const char g_build_version[]  = BUILD_VERSION;
-const char g_build_id[] = BUILD_ID;
-const char g_title_bar_format_idle[] = TITLE_BAR_FORMAT_IDLE;
-const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING;
 const char g_shader_cache_version[] = SHADER_CACHE_VERSION;

 } // namespace
@@ -13,9 +13,6 @@ extern const char g_build_name[];
 extern const char g_build_date[];
 extern const char g_build_fullname[];
 extern const char g_build_version[];
-extern const char g_build_id[];
-extern const char g_title_bar_format_idle[];
-extern const char g_title_bar_format_running[];
 extern const char g_shader_cache_version[];

 } // namespace Common
@@ -335,8 +335,6 @@ add_library(core STATIC
    hle/service/ldr/ldr.h
    hle/service/lm/lm.cpp
    hle/service/lm/lm.h
-    hle/service/lm/manager.cpp
-    hle/service/lm/manager.h
    hle/service/mig/mig.cpp
    hle/service/mig/mig.h
    hle/service/mii/mii.cpp
@@ -35,7 +35,6 @@
 #include "core/hle/service/apm/controller.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/glue/manager.h"
-#include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
@@ -112,8 +111,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 }
 struct System::Impl {
    explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, cpu_core_manager{system},
-          applet_manager{system}, reporter{system} {}
+        : kernel{system}, cpu_core_manager{system}, applet_manager{system}, reporter{system} {}

    Cpu& CurrentCpuCore() {
        return cpu_core_manager.GetCurrentCore();
@@ -251,8 +249,6 @@ struct System::Impl {
        telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS",
                                    perf_stats->GetMeanFrametime());

-        lm_manager.Flush();
-
        is_powered_on = false;
        exit_lock = false;

@@ -343,7 +339,6 @@ struct System::Impl {
    bool is_powered_on = false;
    bool exit_lock = false;

-    Reporter reporter;
    std::unique_ptr<Memory::CheatEngine> cheat_engine;
    std::unique_ptr<Tools::Freezer> memory_freezer;
    std::array<u8, 0x20> build_id{};
@@ -354,9 +349,8 @@ struct System::Impl {
    /// APM (Performance) services
    Service::APM::Controller apm_controller{core_timing};

-    /// Service State
+    /// Glue services
    Service::Glue::ARPManager arp_manager;
-    Service::LM::Manager lm_manager{reporter};

    /// Service manager
    std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -364,6 +358,8 @@ struct System::Impl {
    /// Telemetry session for this emulation session
    std::unique_ptr<Core::TelemetrySession> telemetry_session;

+    Reporter reporter;
+
    ResultStatus status = ResultStatus::Success;
    std::string status_details = "";

@@ -406,12 +402,6 @@ void System::PrepareReschedule() {
    CurrentCpuCore().PrepareReschedule();
 }

-void System::PrepareReschedule(const u32 core_index) {
-    if (core_index < GlobalScheduler().CpuCoresCount()) {
-        CpuCore(core_index).PrepareReschedule();
-    }
-}
-
 PerfStatsResults System::GetAndResetPerfStats() {
    return impl->GetAndResetPerfStats();
 }
@@ -452,16 +442,6 @@ const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
    return CpuCore(core_index).Scheduler();
 }

-/// Gets the global scheduler
-Kernel::GlobalScheduler& System::GlobalScheduler() {
-    return impl->kernel.GlobalScheduler();
-}
-
-/// Gets the global scheduler
-const Kernel::GlobalScheduler& System::GlobalScheduler() const {
-    return impl->kernel.GlobalScheduler();
-}
-
 Kernel::Process* System::CurrentProcess() {
    return impl->kernel.CurrentProcess();
 }
@@ -655,14 +635,6 @@ const Service::APM::Controller& System::GetAPMController() const {
    return impl->apm_controller;
 }

-Service::LM::Manager& System::GetLogManager() {
-    return impl->lm_manager;
-}
-
-const Service::LM::Manager& System::GetLogManager() const {
-    return impl->lm_manager;
-}
-
 void System::SetExitLock(bool locked) {
    impl->exit_lock = locked;
 }
@@ -671,11 +643,11 @@ bool System::GetExitLock() const {
    return impl->exit_lock;
 }

-void System::SetCurrentProcessBuildID(const CurrentBuildProcessID& id) {
+void System::SetCurrentProcessBuildID(std::array<u8, 32> id) {
    impl->build_id = id;
 }

-const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
+const std::array<u8, 32>& System::GetCurrentProcessBuildID() const {
    return impl->build_id;
 }

@@ -8,6 +8,7 @@
 #include <memory>
 #include <string>

+#include <map>
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
@@ -24,7 +25,6 @@ class VfsFilesystem;
 } // namespace FileSys

 namespace Kernel {
-class GlobalScheduler;
 class KernelCore;
 class Process;
 class Scheduler;
@@ -58,10 +58,6 @@ namespace Glue {
 class ARPManager;
 }

-namespace LM {
-class Manager;
-} // namespace LM
-
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -102,8 +98,6 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,

 class System {
 public:
-    using CurrentBuildProcessID = std::array<u8, 0x20>;
-
    System(const System&) = delete;
    System& operator=(const System&) = delete;

@@ -185,9 +179,6 @@ public:
    /// Prepare the core emulation for a reschedule
    void PrepareReschedule();

-    /// Prepare the core emulation for a reschedule
-    void PrepareReschedule(u32 core_index);
-
    /// Gets and resets core performance statistics
    PerfStatsResults GetAndResetPerfStats();

@@ -242,12 +233,6 @@ public:
    /// Gets the scheduler for the CPU core with the specified index
    const Kernel::Scheduler& Scheduler(std::size_t core_index) const;

-    /// Gets the global scheduler
-    Kernel::GlobalScheduler& GlobalScheduler();
-
-    /// Gets the global scheduler
-    const Kernel::GlobalScheduler& GlobalScheduler() const;
-
    /// Provides a pointer to the current process
    Kernel::Process* CurrentProcess();

@@ -341,17 +326,13 @@ public:

    const Service::APM::Controller& GetAPMController() const;

-    Service::LM::Manager& GetLogManager();
-
-    const Service::LM::Manager& GetLogManager() const;
-
    void SetExitLock(bool locked);

    bool GetExitLock() const;

-    void SetCurrentProcessBuildID(const CurrentBuildProcessID& id);
+    void SetCurrentProcessBuildID(std::array<u8, 0x20> id);

-    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
+    const std::array<u8, 0x20>& GetCurrentProcessBuildID() const;

 private:
    System();
@@ -376,4 +357,8 @@ private:
    static System s_instance;
 };

+inline Kernel::Process* CurrentProcess() {
+    return System::GetInstance().CurrentProcess();
+}
+
 } // namespace Core
@@ -52,8 +52,7 @@ bool CpuBarrier::Rendezvous() {

 Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
         std::size_t core_index)
-    : cpu_barrier{cpu_barrier}, global_scheduler{system.GlobalScheduler()},
-      core_timing{system.CoreTiming()}, core_index{core_index} {
+    : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
 #ifdef ARCHITECTURE_x86_64
    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
@@ -61,7 +60,7 @@ Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_ba
    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif

-    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
+    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
 }

 Cpu::~Cpu() = default;
@@ -82,8 +81,6 @@ void Cpu::RunLoop(bool tight_loop) {
        return;
    }

-    Reschedule();
-
    // If we don't have a currently active thread then don't execute instructions,
    // instead advance to the next event and try to yield to the next thread
    if (Kernel::GetCurrentThread() == nullptr) {
@@ -95,6 +92,7 @@ void Cpu::RunLoop(bool tight_loop) {
            core_timing.Advance();
        }

+        PrepareReschedule();
    } else {
        if (IsMainCore()) {
            core_timing.Advance();
@@ -116,14 +114,18 @@ void Cpu::SingleStep() {

 void Cpu::PrepareReschedule() {
    arm_interface->PrepareReschedule();
+    reschedule_pending = true;
 }

 void Cpu::Reschedule() {
-    // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard lock(HLE::g_hle_lock);
+    if (!reschedule_pending) {
+        return;
+    }

-    global_scheduler.SelectThread(core_index);
-    scheduler->TryDoContextSwitch();
+    reschedule_pending = false;
+    // Lock the global kernel mutex when we manipulate the HLE state
+    std::lock_guard lock{HLE::g_hle_lock};
+    scheduler->Reschedule();
 }

 } // namespace Core
@@ -12,9 +12,8 @@
 #include "common/common_types.h"

 namespace Kernel {
-class GlobalScheduler;
 class Scheduler;
-} // namespace Kernel
+}

 namespace Core {
 class System;
@@ -91,7 +90,6 @@ private:

    std::unique_ptr<ARM_Interface> arm_interface;
    CpuBarrier& cpu_barrier;
-    Kernel::GlobalScheduler& global_scheduler;
    std::unique_ptr<Kernel::Scheduler> scheduler;
    Timing::CoreTiming& core_timing;

@@ -423,7 +423,7 @@ static std::optional<u64> FindTicketOffset(const std::array<u8, size>& data) {
 std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
                                                     const RSAKeyPair<2048>& key) {
    const auto issuer = ticket.GetData().issuer;
-    if (IsAllZeroArray(issuer))
+    if (issuer == std::array<u8, 0x40>{})
        return {};
    if (issuer[0] != 'R' || issuer[1] != 'o' || issuer[2] != 'o' || issuer[3] != 't') {
        LOG_INFO(Crypto, "Attempting to parse ticket with non-standard certificate authority.");
@@ -35,11 +35,11 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
    this->update_raw = std::move(update_raw);
 }

-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
+ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() const {
    if (!updatable)
        return MakeResult<VirtualFile>(file);

-    const PatchManager patch_manager(current_process_title_id);
+    const PatchManager patch_manager(Core::CurrentProcess()->GetTitleID());
    return MakeResult<VirtualFile>(
        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
@@ -33,7 +33,7 @@ public:
    ~RomFSFactory();

    void SetPackedUpdate(VirtualFile update_raw);
-    ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    ResultVal<VirtualFile> OpenCurrentProcess() const;
    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type) const;

 private:
@@ -127,9 +127,8 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
                                         u128 user_id, u64 save_id) {
    // 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) {
-        title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-    }
+    if (type == SaveDataType::SaveData && title_id == 0)
+        title_id = Core::CurrentProcess()->GetTitleID();

    std::string out = GetSaveDataSpaceIdPath(space);

@@ -202,11 +202,13 @@ void RegisterModule(std::string name, VAddr beg, VAddr end, bool add_elf_ext) {
 }

 static Kernel::Thread* FindThreadById(s64 id) {
-    const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
-    for (auto& thread : threads) {
-        if (thread->GetThreadID() == static_cast<u64>(id)) {
-            current_core = thread->GetProcessorID();
-            return thread.get();
+    for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+        const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+        for (auto& thread : threads) {
+            if (thread->GetThreadID() == static_cast<u64>(id)) {
+                current_core = core;
+                return thread.get();
+            }
        }
    }
    return nullptr;
@@ -639,15 +641,16 @@ static void HandleQuery() {
                       strlen("Xfer:features:read:target.xml:")) == 0) {
        SendReply(target_xml);
    } else if (strncmp(query, "Offsets", strlen("Offsets")) == 0) {
-        const VAddr base_address =
-            Core::System::GetInstance().CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
+        const VAddr base_address = Core::CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
        std::string buffer = fmt::format("TextSeg={:0x}", base_address);
        SendReply(buffer.c_str());
    } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
        std::string val = "m";
-        const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
-        for (const auto& thread : threads) {
-            val += fmt::format("{:x},", thread->GetThreadID());
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+            for (const auto& thread : threads) {
+                val += fmt::format("{:x},", thread->GetThreadID());
+            }
        }
        val.pop_back();
        SendReply(val.c_str());
@@ -657,11 +660,13 @@ static void HandleQuery() {
        std::string buffer;
        buffer += "l<?xml version=\"1.0\"?>";
        buffer += "<threads>";
-        const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
-        for (const auto& thread : threads) {
-            buffer +=
-                fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
-                            thread->GetThreadID(), thread->GetProcessorID(), thread->GetThreadID());
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core).GetThreadList();
+            for (const auto& thread : threads) {
+                buffer +=
+                    fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
+                                thread->GetThreadID(), core, thread->GetThreadID());
+            }
        }
        buffer += "</threads>";
        SendReply(buffer.c_str());
@@ -22,7 +22,6 @@ namespace Kernel {
 namespace {
 // Wake up num_to_wake (or all) threads in a vector.
 void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
-    auto& system = Core::System::GetInstance();
    // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
    // them all.
    std::size_t last = waiting_threads.size();
@@ -36,7 +35,6 @@ void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_
        waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
        waiting_threads[i]->SetArbiterWaitAddress(0);
        waiting_threads[i]->ResumeFromWait();
-        system.PrepareReschedule(waiting_threads[i]->GetProcessorID());
    }
 }
 } // Anonymous namespace
@@ -171,22 +169,30 @@ ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {

    current_thread->WakeAfterDelay(timeout);

-    system.PrepareReschedule(current_thread->GetProcessorID());
+    system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
    return RESULT_TIMEOUT;
 }

 std::vector<SharedPtr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) const {
+    const auto RetrieveWaitingThreads = [this](std::size_t core_index,
+                                               std::vector<SharedPtr<Thread>>& waiting_threads,
+                                               VAddr arb_addr) {
+        const auto& scheduler = system.Scheduler(core_index);
+        const auto& thread_list = scheduler.GetThreadList();
+
+        for (const auto& thread : thread_list) {
+            if (thread->GetArbiterWaitAddress() == arb_addr) {
+                waiting_threads.push_back(thread);
+            }
+        }
+    };

    // Retrieve all threads that are waiting for this address.
    std::vector<SharedPtr<Thread>> threads;
-    const auto& scheduler = system.GlobalScheduler();
-    const auto& thread_list = scheduler.GetThreadList();
-
-    for (const auto& thread : thread_list) {
-        if (thread->GetArbiterWaitAddress() == address) {
-            threads.push_back(thread);
-        }
-    }
+    RetrieveWaitingThreads(0, threads, address);
+    RetrieveWaitingThreads(1, threads, address);
+    RetrieveWaitingThreads(2, threads, address);
+    RetrieveWaitingThreads(3, threads, address);

    // Sort them by priority, such that the highest priority ones come first.
    std::sort(threads.begin(), threads.end(),
@@ -103,7 +103,7 @@ SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
    if (handle == CurrentThread) {
        return GetCurrentThread();
    } else if (handle == CurrentProcess) {
-        return Core::System::GetInstance().CurrentProcess();
+        return Core::CurrentProcess();
    }

    if (!IsValid(handle)) {
@@ -18,7 +18,6 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
@@ -89,7 +88,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
 }

 struct KernelCore::Impl {
-    explicit Impl(Core::System& system) : system{system}, global_scheduler{system} {}
+    explicit Impl(Core::System& system) : system{system} {}

    void Initialize(KernelCore& kernel) {
        Shutdown();
@@ -141,7 +140,6 @@ struct KernelCore::Impl {
    // Lists all processes that exist in the current session.
    std::vector<SharedPtr<Process>> process_list;
    Process* current_process = nullptr;
-    Kernel::GlobalScheduler global_scheduler;

    SharedPtr<ResourceLimit> system_resource_limit;

@@ -205,14 +203,6 @@ const std::vector<SharedPtr<Process>>& KernelCore::GetProcessList() const {
    return impl->process_list;
 }

-Kernel::GlobalScheduler& KernelCore::GlobalScheduler() {
-    return impl->global_scheduler;
-}
-
-const Kernel::GlobalScheduler& KernelCore::GlobalScheduler() const {
-    return impl->global_scheduler;
-}
-
 void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
    impl->named_ports.emplace(std::move(name), std::move(port));
 }
@@ -25,7 +25,6 @@ class HandleTable;
 class Process;
 class ResourceLimit;
 class Thread;
-class GlobalScheduler;

 /// Represents a single instance of the kernel.
 class KernelCore {
@@ -76,12 +75,6 @@ public:
    /// Retrieves the list of processes.
    const std::vector<SharedPtr<Process>>& GetProcessList() const;

-    /// Gets the sole instance of the global scheduler
-    Kernel::GlobalScheduler& GlobalScheduler();
-
-    /// Gets the sole instance of the global scheduler
-    const Kernel::GlobalScheduler& GlobalScheduler() const;
-
    /// Adds a port to the named port table
    void AddNamedPort(std::string name, SharedPtr<ClientPort> port);

@@ -7,7 +7,6 @@

 #include "common/assert.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
@@ -79,7 +78,7 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
    // thread.
    ASSERT(requesting_thread == current_thread);

-    u32 addr_value = Memory::Read32(address);
+    const u32 addr_value = Memory::Read32(address);

    // If the mutex isn't being held, just return success.
    if (addr_value != (holding_thread_handle | Mutex::MutexHasWaitersFlag)) {
@@ -90,20 +89,6 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
        return ERR_INVALID_HANDLE;
    }

-    // This a workaround where an unknown bug writes the mutex value to give ownership to a cond var
-    // waiting thread.
-    if (holding_thread->GetStatus() == ThreadStatus::WaitCondVar) {
-        if (holding_thread->GetMutexWaitAddress() == address) {
-            Release(address, holding_thread.get());
-            addr_value = Memory::Read32(address);
-            if (addr_value == 0)
-                return RESULT_SUCCESS;
-            else {
-                holding_thread = handle_table.Get<Thread>(addr_value & Mutex::MutexOwnerMask);
-            }
-        }
-    }
-
    // Wait until the mutex is released
    current_thread->SetMutexWaitAddress(address);
    current_thread->SetWaitHandle(requesting_thread_handle);
@@ -119,13 +104,14 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
    return RESULT_SUCCESS;
 }

-ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
+ResultCode Mutex::Release(VAddr address) {
    // The mutex address must be 4-byte aligned
    if ((address % sizeof(u32)) != 0) {
        return ERR_INVALID_ADDRESS;
    }

-    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(holding_thread, address);
+    auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
+    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(current_thread, address);

    // There are no more threads waiting for the mutex, release it completely.
    if (thread == nullptr) {
@@ -134,7 +120,7 @@ ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
    }

    // Transfer the ownership of the mutex from the previous owner to the new one.
-    TransferMutexOwnership(address, holding_thread, thread);
+    TransferMutexOwnership(address, current_thread, thread);

    u32 mutex_value = thread->GetWaitHandle();

@@ -154,11 +140,6 @@ ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
    thread->SetMutexWaitAddress(0);
    thread->SetWaitHandle(0);

-    if (thread->GetProcessorID() >= 0)
-        system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
-    if (holding_thread->GetProcessorID() >= 0)
-        system.CpuCore(holding_thread->GetProcessorID()).PrepareReschedule();
-
    return RESULT_SUCCESS;
 }
 } // namespace Kernel
@@ -29,7 +29,7 @@ public:
                          Handle requesting_thread_handle);

    /// Releases the mutex at the specified address.
-    ResultCode Release(VAddr address, Thread* holding_thread);
+    ResultCode Release(VAddr address);

 private:
    Core::System& system;
@@ -213,7 +213,10 @@ void Process::PrepareForTermination() {
        }
    };

-    stop_threads(system.GlobalScheduler().GetThreadList());
+    stop_threads(system.Scheduler(0).GetThreadList());
+    stop_threads(system.Scheduler(1).GetThreadList());
+    stop_threads(system.Scheduler(2).GetThreadList());
+    stop_threads(system.Scheduler(3).GetThreadList());

    FreeTLSRegion(tls_region_address);
    tls_region_address = 0;
@@ -1,13 +1,8 @@
 // Copyright 2018 yuzu emulator team
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-//
-// SelectThreads, Yield functions originally by TuxSH.
-// licensed under GPLv2 or later under exception provided by the author.

 #include <algorithm>
-#include <set>
-#include <unordered_set>
 #include <utility>

 #include "common/assert.h"
@@ -22,277 +17,56 @@

 namespace Kernel {

-GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {
-    reselection_pending = false;
-}
+std::mutex Scheduler::scheduler_mutex;

-void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
-    thread_list.push_back(std::move(thread));
-}
+Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core)
+    : cpu_core{cpu_core}, system{system} {}

-void GlobalScheduler::RemoveThread(const Thread* thread) {
-    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
-                      thread_list.end());
-}
-
-/*
- * UnloadThread selects a core and forces it to unload its current thread's context
- */
-void GlobalScheduler::UnloadThread(s32 core) {
-    Scheduler& sched = system.Scheduler(core);
-    sched.UnloadThread();
-}
-
-/*
- * SelectThread takes care of selecting the new scheduled thread.
- * It does it in 3 steps:
- * - First a thread is selected from the top of the priority queue. If no thread
- * is obtained then we move to step two, else we are done.
- * - Second we try to get a suggested thread that's not assigned to any core or
- * that is not the top thread in that core.
- * - Third is no suggested thread is found, we do a second pass and pick a running
- * thread in another core and swap it with its current thread.
- */
-void GlobalScheduler::SelectThread(u32 core) {
-    const auto update_thread = [](Thread* thread, Scheduler& sched) {
-        if (thread != sched.selected_thread) {
-            if (thread == nullptr) {
-                ++sched.idle_selection_count;
-            }
-            sched.selected_thread = thread;
-        }
-        sched.context_switch_pending = sched.selected_thread != sched.current_thread;
-        std::atomic_thread_fence(std::memory_order_seq_cst);
-    };
-    Scheduler& sched = system.Scheduler(core);
-    Thread* current_thread = nullptr;
-    // Step 1: Get top thread in schedule queue.
-    current_thread = scheduled_queue[core].empty() ? nullptr : scheduled_queue[core].front();
-    if (current_thread) {
-        update_thread(current_thread, sched);
-        return;
-    }
-    // Step 2: Try selecting a suggested thread.
-    Thread* winner = nullptr;
-    std::set<s32> sug_cores;
-    for (auto thread : suggested_queue[core]) {
-        s32 this_core = thread->GetProcessorID();
-        Thread* thread_on_core = nullptr;
-        if (this_core >= 0) {
-            thread_on_core = scheduled_queue[this_core].front();
-        }
-        if (this_core < 0 || thread != thread_on_core) {
-            winner = thread;
-            break;
-        }
-        sug_cores.insert(this_core);
-    }
-    // if we got a suggested thread, select it, else do a second pass.
-    if (winner && winner->GetPriority() > 2) {
-        if (winner->IsRunning()) {
-            UnloadThread(winner->GetProcessorID());
-        }
-        TransferToCore(winner->GetPriority(), core, winner);
-        update_thread(winner, sched);
-        return;
-    }
-    // Step 3: Select a suggested thread from another core
-    for (auto& src_core : sug_cores) {
-        auto it = scheduled_queue[src_core].begin();
-        it++;
-        if (it != scheduled_queue[src_core].end()) {
-            Thread* thread_on_core = scheduled_queue[src_core].front();
-            Thread* to_change = *it;
-            if (thread_on_core->IsRunning() || to_change->IsRunning()) {
-                UnloadThread(src_core);
-            }
-            TransferToCore(thread_on_core->GetPriority(), core, thread_on_core);
-            current_thread = thread_on_core;
-            break;
-        }
-    }
-    update_thread(current_thread, sched);
-}
-
-/*
- * YieldThread takes a thread and moves it to the back of the it's priority list
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
-void GlobalScheduler::YieldThread(Thread* yielding_thread) {
-    // Note: caller should use critical section, etc.
-    const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
-    const u32 priority = yielding_thread->GetPriority();
-
-    // Yield the thread
-    ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority),
-               "Thread yielding without being in front");
-    scheduled_queue[core_id].yield(priority);
-
-    Thread* winner = scheduled_queue[core_id].front(priority);
-    AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-/*
- * YieldThreadAndBalanceLoad takes a thread and moves it to the back of the it's priority list.
- * Afterwards, tries to pick a suggested thread from the suggested queue that has worse time or
- * a better priority than the next thread in the core.
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
-void GlobalScheduler::YieldThreadAndBalanceLoad(Thread* yielding_thread) {
-    // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
-    // etc.
-    const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
-    const u32 priority = yielding_thread->GetPriority();
-
-    // Yield the thread
-    ASSERT_MSG(yielding_thread == scheduled_queue[core_id].front(priority),
-               "Thread yielding without being in front");
-    scheduled_queue[core_id].yield(priority);
-
-    std::array<Thread*, NUM_CPU_CORES> current_threads;
-    for (u32 i = 0; i < NUM_CPU_CORES; i++) {
-        current_threads[i] = scheduled_queue[i].empty() ? nullptr : scheduled_queue[i].front();
-    }
-
-    Thread* next_thread = scheduled_queue[core_id].front(priority);
-    Thread* winner = nullptr;
-    for (auto& thread : suggested_queue[core_id]) {
-        const s32 source_core = thread->GetProcessorID();
-        if (source_core >= 0) {
-            if (current_threads[source_core] != nullptr) {
-                if (thread == current_threads[source_core] ||
-                    current_threads[source_core]->GetPriority() < min_regular_priority) {
-                    continue;
-                }
-            }
-            if (next_thread->GetLastRunningTicks() >= thread->GetLastRunningTicks() ||
-                next_thread->GetPriority() < thread->GetPriority()) {
-                if (thread->GetPriority() <= priority) {
-                    winner = thread;
-                    break;
-                }
-            }
-        }
-    }
-
-    if (winner != nullptr) {
-        if (winner != yielding_thread) {
-            if (winner->IsRunning()) {
-                UnloadThread(winner->GetProcessorID());
-            }
-            TransferToCore(winner->GetPriority(), core_id, winner);
-        }
-    } else {
-        winner = next_thread;
-    }
-
-    AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-/*
- * YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
- * and into the suggested queue. If no thread can be squeduled afterwards in that core,
- * a suggested thread is obtained instead.
- * This operation can be redundant and no scheduling is changed if marked as so.
- */
-void GlobalScheduler::YieldThreadAndWaitForLoadBalancing(Thread* yielding_thread) {
-    // Note: caller should check if !thread.IsSchedulerOperationRedundant and use critical section,
-    // etc.
-    Thread* winner = nullptr;
-    const u32 core_id = static_cast<u32>(yielding_thread->GetProcessorID());
-
-    // Remove the thread from its scheduled mlq, put it on the corresponding "suggested" one instead
-    TransferToCore(yielding_thread->GetPriority(), -1, yielding_thread);
-
-    // If the core is idle, perform load balancing, excluding the threads that have just used this
-    // function...
-    if (scheduled_queue[core_id].empty()) {
-        // Here, "current_threads" is calculated after the ""yield"", unlike yield -1
-        std::array<Thread*, NUM_CPU_CORES> current_threads;
-        for (u32 i = 0; i < NUM_CPU_CORES; i++) {
-            current_threads[i] = scheduled_queue[i].empty() ? nullptr : scheduled_queue[i].front();
-        }
-        for (auto& thread : suggested_queue[core_id]) {
-            const s32 source_core = thread->GetProcessorID();
-            if (source_core < 0 || thread == current_threads[source_core]) {
-                continue;
-            }
-            if (current_threads[source_core] == nullptr ||
-                current_threads[source_core]->GetPriority() >= min_regular_priority) {
-                winner = thread;
-            }
-            break;
-        }
-        if (winner != nullptr) {
-            if (winner != yielding_thread) {
-                if (winner->IsRunning()) {
-                    UnloadThread(winner->GetProcessorID());
-                }
-                TransferToCore(winner->GetPriority(), core_id, winner);
-            }
-        } else {
-            winner = yielding_thread;
-        }
-    }
-
-    AskForReselectionOrMarkRedundant(yielding_thread, winner);
-}
-
-void GlobalScheduler::Schedule(u32 priority, u32 core, Thread* thread) {
-    ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core.");
-    scheduled_queue[core].add(thread, priority);
-}
-
-void GlobalScheduler::SchedulePrepend(u32 priority, u32 core, Thread* thread) {
-    ASSERT_MSG(thread->GetProcessorID() == core, "Thread must be assigned to this core.");
-    scheduled_queue[core].add(thread, priority, false);
-}
-
-void GlobalScheduler::AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner) {
-    if (current_thread == winner) {
-        // TODO(blinkhawk): manage redundant operations, this is not implemented.
-        // as its mostly an optimization.
-        // current_thread->SetRedundantSchedulerOperation();
-    } else {
-        reselection_pending.store(true, std::memory_order_release);
+Scheduler::~Scheduler() {
+    for (auto& thread : thread_list) {
+        thread->Stop();
    }
 }

-GlobalScheduler::~GlobalScheduler() = default;
-
-Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, u32 core_id)
-    : system(system), cpu_core(cpu_core), core_id(core_id) {}
-
-Scheduler::~Scheduler() = default;
-
 bool Scheduler::HaveReadyThreads() const {
-    return system.GlobalScheduler().HaveReadyThreads(core_id);
+    std::lock_guard lock{scheduler_mutex};
+    return !ready_queue.empty();
 }

 Thread* Scheduler::GetCurrentThread() const {
    return current_thread.get();
 }

-Thread* Scheduler::GetSelectedThread() const {
-    return selected_thread.get();
-}
-
-void Scheduler::SelectThreads() {
-    system.GlobalScheduler().SelectThread(core_id);
-}
-
 u64 Scheduler::GetLastContextSwitchTicks() const {
    return last_context_switch_time;
 }

-void Scheduler::TryDoContextSwitch() {
-    if (context_switch_pending) {
-        SwitchContext();
+Thread* Scheduler::PopNextReadyThread() {
+    Thread* next = nullptr;
+    Thread* thread = GetCurrentThread();
+
+    if (thread && thread->GetStatus() == ThreadStatus::Running) {
+        if (ready_queue.empty()) {
+            return thread;
+        }
+        // We have to do better than the current thread.
+        // This call returns null when that's not possible.
+        next = ready_queue.front();
+        if (next == nullptr || next->GetPriority() >= thread->GetPriority()) {
+            next = thread;
+        }
+    } else {
+        if (ready_queue.empty()) {
+            return nullptr;
+        }
+        next = ready_queue.front();
    }
+
+    return next;
 }

-void Scheduler::UnloadThread() {
-    Thread* const previous_thread = GetCurrentThread();
+void Scheduler::SwitchContext(Thread* new_thread) {
+    Thread* previous_thread = GetCurrentThread();
    Process* const previous_process = system.Kernel().CurrentProcess();

    UpdateLastContextSwitchTime(previous_thread, previous_process);
@@ -306,52 +80,23 @@ void Scheduler::UnloadThread() {
        if (previous_thread->GetStatus() == ThreadStatus::Running) {
            // This is only the case when a reschedule is triggered without the current thread
            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
+            ready_queue.add(previous_thread, previous_thread->GetPriority(), false);
            previous_thread->SetStatus(ThreadStatus::Ready);
        }
-        previous_thread->SetIsRunning(false);
-    }
-    current_thread = nullptr;
-}
-
-void Scheduler::SwitchContext() {
-    Thread* const previous_thread = GetCurrentThread();
-    Thread* const new_thread = GetSelectedThread();
-
-    context_switch_pending = false;
-    if (new_thread == previous_thread) {
-        return;
-    }
-
-    Process* const previous_process = system.Kernel().CurrentProcess();
-
-    UpdateLastContextSwitchTime(previous_thread, previous_process);
-
-    // Save context for previous thread
-    if (previous_thread) {
-        cpu_core.SaveContext(previous_thread->GetContext());
-        // Save the TPIDR_EL0 system register in case it was modified.
-        previous_thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());
-
-        if (previous_thread->GetStatus() == ThreadStatus::Running) {
-            // This is only the case when a reschedule is triggered without the current thread
-            // yielding execution (i.e. an event triggered, system core time-sliced, etc)
-            previous_thread->SetStatus(ThreadStatus::Ready);
-        }
-        previous_thread->SetIsRunning(false);
    }

    // Load context of new thread
    if (new_thread) {
-        ASSERT_MSG(new_thread->GetProcessorID() == this->core_id,
-                   "Thread must be assigned to this core.");
        ASSERT_MSG(new_thread->GetStatus() == ThreadStatus::Ready,
                   "Thread must be ready to become running.");

        // Cancel any outstanding wakeup events for this thread
        new_thread->CancelWakeupTimer();
+
        current_thread = new_thread;
+
+        ready_queue.remove(new_thread, new_thread->GetPriority());
        new_thread->SetStatus(ThreadStatus::Running);
-        new_thread->SetIsRunning(true);

        auto* const thread_owner_process = current_thread->GetOwnerProcess();
        if (previous_process != thread_owner_process) {
@@ -385,4 +130,124 @@ void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
    last_context_switch_time = most_recent_switch_ticks;
 }

+void Scheduler::Reschedule() {
+    std::lock_guard lock{scheduler_mutex};
+
+    Thread* cur = GetCurrentThread();
+    Thread* next = PopNextReadyThread();
+
+    if (cur && next) {
+        LOG_TRACE(Kernel, "context switch {} -> {}", cur->GetObjectId(), next->GetObjectId());
+    } else if (cur) {
+        LOG_TRACE(Kernel, "context switch {} -> idle", cur->GetObjectId());
+    } else if (next) {
+        LOG_TRACE(Kernel, "context switch idle -> {}", next->GetObjectId());
+    }
+
+    SwitchContext(next);
+}
+
+void Scheduler::AddThread(SharedPtr<Thread> thread) {
+    std::lock_guard lock{scheduler_mutex};
+
+    thread_list.push_back(std::move(thread));
+}
+
+void Scheduler::RemoveThread(Thread* thread) {
+    std::lock_guard lock{scheduler_mutex};
+
+    thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
+                      thread_list.end());
+}
+
+void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
+    std::lock_guard lock{scheduler_mutex};
+
+    ASSERT(thread->GetStatus() == ThreadStatus::Ready);
+    ready_queue.add(thread, priority);
+}
+
+void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
+    std::lock_guard lock{scheduler_mutex};
+
+    ASSERT(thread->GetStatus() == ThreadStatus::Ready);
+    ready_queue.remove(thread, priority);
+}
+
+void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
+    std::lock_guard lock{scheduler_mutex};
+    if (thread->GetPriority() == priority) {
+        return;
+    }
+
+    // If thread was ready, adjust queues
+    if (thread->GetStatus() == ThreadStatus::Ready)
+        ready_queue.adjust(thread, thread->GetPriority(), priority);
+}
+
+Thread* Scheduler::GetNextSuggestedThread(u32 core, u32 maximum_priority) const {
+    std::lock_guard lock{scheduler_mutex};
+
+    const u32 mask = 1U << core;
+    for (auto* thread : ready_queue) {
+        if ((thread->GetAffinityMask() & mask) != 0 && thread->GetPriority() < maximum_priority) {
+            return thread;
+        }
+    }
+    return nullptr;
+}
+
+void Scheduler::YieldWithoutLoadBalancing(Thread* thread) {
+    ASSERT(thread != nullptr);
+    // Avoid yielding if the thread isn't even running.
+    ASSERT(thread->GetStatus() == ThreadStatus::Running);
+
+    // Sanity check that the priority is valid
+    ASSERT(thread->GetPriority() < THREADPRIO_COUNT);
+
+    // Yield this thread -- sleep for zero time and force reschedule to different thread
+    GetCurrentThread()->Sleep(0);
+}
+
+void Scheduler::YieldWithLoadBalancing(Thread* thread) {
+    ASSERT(thread != nullptr);
+    const auto priority = thread->GetPriority();
+    const auto core = static_cast<u32>(thread->GetProcessorID());
+
+    // Avoid yielding if the thread isn't even running.
+    ASSERT(thread->GetStatus() == ThreadStatus::Running);
+
+    // Sanity check that the priority is valid
+    ASSERT(priority < THREADPRIO_COUNT);
+
+    // Sleep for zero time to be able to force reschedule to different thread
+    GetCurrentThread()->Sleep(0);
+
+    Thread* suggested_thread = nullptr;
+
+    // Search through all of the cpu cores (except this one) for a suggested thread.
+    // Take the first non-nullptr one
+    for (unsigned cur_core = 0; cur_core < Core::NUM_CPU_CORES; ++cur_core) {
+        const auto res =
+            system.CpuCore(cur_core).Scheduler().GetNextSuggestedThread(core, priority);
+
+        // If scheduler provides a suggested thread
+        if (res != nullptr) {
+            // And its better than the current suggested thread (or is the first valid one)
+            if (suggested_thread == nullptr ||
+                suggested_thread->GetPriority() > res->GetPriority()) {
+                suggested_thread = res;
+            }
+        }
+    }
+
+    // If a suggested thread was found, queue that for this core
+    if (suggested_thread != nullptr)
+        suggested_thread->ChangeCore(core, suggested_thread->GetAffinityMask());
+}
+
+void Scheduler::YieldAndWaitForLoadBalancing(Thread* thread) {
+    UNIMPLEMENTED_MSG("Wait for load balancing thread yield type is not implemented!");
+}
+
 } // namespace Kernel
@@ -20,178 +20,124 @@ namespace Kernel {

 class Process;

-class GlobalScheduler final {
-public:
-    static constexpr u32 NUM_CPU_CORES = 4;
-
-    explicit GlobalScheduler(Core::System& system);
-    ~GlobalScheduler();
-    /// Adds a new thread to the scheduler
-    void AddThread(SharedPtr<Thread> thread);
-
-    /// Removes a thread from the scheduler
-    void RemoveThread(const Thread* thread);
-
-    /// Returns a list of all threads managed by the scheduler
-    const std::vector<SharedPtr<Thread>>& GetThreadList() const {
-        return thread_list;
-    }
-
-    // Add a thread to the suggested queue of a cpu core. Suggested threads may be
-    // picked if no thread is scheduled to run on the core.
-    void Suggest(u32 priority, u32 core, Thread* thread) {
-        suggested_queue[core].add(thread, priority);
-    }
-
-    // Remove a thread to the suggested queue of a cpu core. Suggested threads may be
-    // picked if no thread is scheduled to run on the core.
-    void Unsuggest(u32 priority, u32 core, Thread* thread) {
-        suggested_queue[core].remove(thread, priority);
-    }
-
-    // Add a thread to the scheduling queue of a cpu core. The thread is added at the
-    // back the queue in its priority level
-    void Schedule(u32 priority, u32 core, Thread* thread);
-
-    // Add a thread to the scheduling queue of a cpu core. The thread is added at the
-    // front the queue in its priority level
-    void SchedulePrepend(u32 priority, u32 core, Thread* thread);
-
-    // Reschedule an already scheduled thread based on a new priority
-    void Reschedule(u32 priority, u32 core, Thread* thread) {
-        scheduled_queue[core].remove(thread, priority);
-        scheduled_queue[core].add(thread, priority);
-    }
-
-    // Unschedule a thread.
-    void Unschedule(u32 priority, u32 core, Thread* thread) {
-        scheduled_queue[core].remove(thread, priority);
-    }
-
-    // Transfers a thread into an specific core. If the destination_core is -1
-    // it will be unscheduled from its source code and added into its suggested
-    // queue.
-    void TransferToCore(u32 priority, s32 destination_core, Thread* thread) {
-        const bool schedulable = thread->GetPriority() < THREADPRIO_COUNT;
-        const s32 source_core = thread->GetProcessorID();
-        if (source_core == destination_core || !schedulable) {
-            return;
-        }
-        thread->SetProcessorID(destination_core);
-        if (source_core >= 0) {
-            Unschedule(priority, source_core, thread);
-        }
-        if (destination_core >= 0) {
-            Unsuggest(priority, destination_core, thread);
-            Schedule(priority, destination_core, thread);
-        }
-        if (source_core >= 0) {
-            Suggest(priority, source_core, thread);
-        }
-    }
-
-    /*
-     * UnloadThread selects a core and forces it to unload its current thread's context
-     */
-    void UnloadThread(s32 core);
-
-    /*
-     * SelectThread takes care of selecting the new scheduled thread.
-     * It does it in 3 steps:
-     * - First a thread is selected from the top of the priority queue. If no thread
-     * is obtained then we move to step two, else we are done.
-     * - Second we try to get a suggested thread that's not assigned to any core or
-     * that is not the top thread in that core.
-     * - Third is no suggested thread is found, we do a second pass and pick a running
-     * thread in another core and swap it with its current thread.
-     */
-    void SelectThread(u32 core);
-
-    bool HaveReadyThreads(u32 core_id) const {
-        return !scheduled_queue[core_id].empty();
-    }
-
-    /*
-     * YieldThread takes a thread and moves it to the back of the it's priority list
-     * This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    void YieldThread(Thread* thread);
-
-    /*
-     * YieldThreadAndBalanceLoad takes a thread and moves it to the back of the it's priority list.
-     * Afterwards, tries to pick a suggested thread from the suggested queue that has worse time or
-     * a better priority than the next thread in the core.
-     * This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    void YieldThreadAndBalanceLoad(Thread* thread);
-
-    /*
-     * YieldThreadAndWaitForLoadBalancing takes a thread and moves it out of the scheduling queue
-     * and into the suggested queue. If no thread can be squeduled afterwards in that core,
-     * a suggested thread is obtained instead.
-     * This operation can be redundant and no scheduling is changed if marked as so.
-     */
-    void YieldThreadAndWaitForLoadBalancing(Thread* thread);
-
-    u32 CpuCoresCount() const {
-        return NUM_CPU_CORES;
-    }
-
-    void SetReselectionPending() {
-        reselection_pending.store(true, std::memory_order_release);
-    }
-
-    bool IsReselectionPending() const {
-        return reselection_pending.load();
-    }
-
-private:
-    void AskForReselectionOrMarkRedundant(Thread* current_thread, Thread* winner);
-
-    static constexpr u32 min_regular_priority = 2;
-    std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> scheduled_queue;
-    std::array<Common::MultiLevelQueue<Thread*, THREADPRIO_COUNT>, NUM_CPU_CORES> suggested_queue;
-    std::atomic<bool> reselection_pending;
-
-    /// Lists all thread ids that aren't deleted/etc.
-    std::vector<SharedPtr<Thread>> thread_list;
-    Core::System& system;
-};
-
 class Scheduler final {
 public:
-    explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, const u32 core_id);
+    explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core);
    ~Scheduler();

    /// Returns whether there are any threads that are ready to run.
    bool HaveReadyThreads() const;

    /// Reschedules to the next available thread (call after current thread is suspended)
-    void TryDoContextSwitch();
-
-    void UnloadThread();
-
-    void SelectThreads();
+    void Reschedule();

    /// Gets the current running thread
    Thread* GetCurrentThread() const;

-    Thread* GetSelectedThread() const;
-
    /// Gets the timestamp for the last context switch in ticks.
    u64 GetLastContextSwitchTicks() const;

-    bool ContextSwitchPending() const {
-        return context_switch_pending;
+    /// Adds a new thread to the scheduler
+    void AddThread(SharedPtr<Thread> thread);
+
+    /// Removes a thread from the scheduler
+    void RemoveThread(Thread* thread);
+
+    /// Schedules a thread that has become "ready"
+    void ScheduleThread(Thread* thread, u32 priority);
+
+    /// Unschedules a thread that was already scheduled
+    void UnscheduleThread(Thread* thread, u32 priority);
+
+    /// Sets the priority of a thread in the scheduler
+    void SetThreadPriority(Thread* thread, u32 priority);
+
+    /// Gets the next suggested thread for load balancing
+    Thread* GetNextSuggestedThread(u32 core, u32 minimum_priority) const;
+
+    /**
+     * YieldWithoutLoadBalancing -- analogous to normal yield on a system
+     * Moves the thread to the end of the ready queue for its priority, and then reschedules the
+     * system to the new head of the queue.
+     *
+     * Example (Single Core -- but can be extrapolated to multi):
+     * ready_queue[prio=0]: ThreadA, ThreadB, ThreadC (->exec order->)
+     * Currently Running: ThreadR
+     *
+     * ThreadR calls YieldWithoutLoadBalancing
+     *
+     * ThreadR is moved to the end of ready_queue[prio=0]:
+     * ready_queue[prio=0]: ThreadA, ThreadB, ThreadC, ThreadR (->exec order->)
+     * Currently Running: Nothing
+     *
+     * System is rescheduled (ThreadA is popped off of queue):
+     * ready_queue[prio=0]: ThreadB, ThreadC, ThreadR (->exec order->)
+     * Currently Running: ThreadA
+     *
+     * If the queue is empty at time of call, no yielding occurs. This does not cross between cores
+     * or priorities at all.
+     */
+    void YieldWithoutLoadBalancing(Thread* thread);
+
+    /**
+     * YieldWithLoadBalancing -- yield but with better selection of the new running thread
+     * Moves the current thread to the end of the ready queue for its priority, then selects a
+     * 'suggested thread' (a thread on a different core that could run on this core) from the
+     * scheduler, changes its core, and reschedules the current core to that thread.
+     *
+     * Example (Dual Core -- can be extrapolated to Quad Core, this is just normal yield if it were
+     * single core):
+     * ready_queue[core=0][prio=0]: ThreadA, ThreadB (affinities not pictured as irrelevant
+     * ready_queue[core=1][prio=0]: ThreadC[affinity=both], ThreadD[affinity=core1only]
+     * Currently Running: ThreadQ on Core 0 || ThreadP on Core 1
+     *
+     * ThreadQ calls YieldWithLoadBalancing
+     *
+     * ThreadQ is moved to the end of ready_queue[core=0][prio=0]:
+     * ready_queue[core=0][prio=0]: ThreadA, ThreadB
+     * ready_queue[core=1][prio=0]: ThreadC[affinity=both], ThreadD[affinity=core1only]
+     * Currently Running: ThreadQ on Core 0 || ThreadP on Core 1
+     *
+     * A list of suggested threads for each core is compiled
+     * Suggested Threads: {ThreadC on Core 1}
+     * If this were quad core (as the switch is), there could be between 0 and 3 threads in this
+     * list. If there are more than one, the thread is selected by highest prio.
+     *
+     * ThreadC is core changed to Core 0:
+     * ready_queue[core=0][prio=0]: ThreadC, ThreadA, ThreadB, ThreadQ
+     * ready_queue[core=1][prio=0]: ThreadD
+     * Currently Running: None on Core 0 || ThreadP on Core 1
+     *
+     * System is rescheduled (ThreadC is popped off of queue):
+     * ready_queue[core=0][prio=0]: ThreadA, ThreadB, ThreadQ
+     * ready_queue[core=1][prio=0]: ThreadD
+     * Currently Running: ThreadC on Core 0 || ThreadP on Core 1
+     *
+     * If no suggested threads can be found this will behave just as normal yield. If there are
+     * multiple candidates for the suggested thread on a core, the highest prio is taken.
+     */
+    void YieldWithLoadBalancing(Thread* thread);
+
+    /// Currently unknown -- asserts as unimplemented on call
+    void YieldAndWaitForLoadBalancing(Thread* thread);
+
+    /// Returns a list of all threads managed by the scheduler
+    const std::vector<SharedPtr<Thread>>& GetThreadList() const {
+        return thread_list;
    }

 private:
-    friend class GlobalScheduler;
+    /**
+     * Pops and returns the next thread from the thread queue
+     * @return A pointer to the next ready thread
+     */
+    Thread* PopNextReadyThread();
+
    /**
     * Switches the CPU's active thread context to that of the specified thread
     * @param new_thread The thread to switch to
     */
-    void SwitchContext();
+    void SwitchContext(Thread* new_thread);

    /**
     * Called on every context switch to update the internal timestamp
@@ -206,16 +152,19 @@ private:
     */
    void UpdateLastContextSwitchTime(Thread* thread, Process* process);

+    /// Lists all thread ids that aren't deleted/etc.
+    std::vector<SharedPtr<Thread>> thread_list;
+
+    /// Lists only ready thread ids.
+    Common::MultiLevelQueue<Thread*, THREADPRIO_LOWEST + 1> ready_queue;
+
    SharedPtr<Thread> current_thread = nullptr;
-    SharedPtr<Thread> selected_thread = nullptr;

-    Core::System& system;
    Core::ARM_Interface& cpu_core;
    u64 last_context_switch_time = 0;
-    u64 idle_selection_count = 0;
-    const u32 core_id;

-    bool context_switch_pending = false;
+    Core::System& system;
+    static std::mutex scheduler_mutex;
 };

 } // namespace Kernel
@@ -516,7 +516,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
    thread->WakeAfterDelay(nano_seconds);
    thread->SetWakeupCallback(DefaultThreadWakeupCallback);

-    system.PrepareReschedule(thread->GetProcessorID());
+    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();

    return RESULT_TIMEOUT;
 }
@@ -534,7 +534,6 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
    }

    thread->CancelWait();
-    system.PrepareReschedule(thread->GetProcessorID());
    return RESULT_SUCCESS;
 }

@@ -578,8 +577,7 @@ static ResultCode ArbitrateUnlock(Core::System& system, VAddr mutex_addr) {
    }

    auto* const current_process = system.Kernel().CurrentProcess();
-    return current_process->GetMutex().Release(mutex_addr,
-                                               system.CurrentScheduler().GetCurrentThread());
+    return current_process->GetMutex().Release(mutex_addr);
 }

 enum class BreakType : u32 {
@@ -1068,8 +1066,6 @@ static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 act
    }

    thread->SetActivity(static_cast<ThreadActivity>(activity));
-
-    system.PrepareReschedule(thread->GetProcessorID());
    return RESULT_SUCCESS;
 }

@@ -1151,7 +1147,7 @@ static ResultCode SetThreadPriority(Core::System& system, Handle handle, u32 pri

    thread->SetPriority(priority);

-    system.PrepareReschedule(thread->GetProcessorID());
+    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
    return RESULT_SUCCESS;
 }

@@ -1507,7 +1503,7 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e
    thread->SetName(
        fmt::format("thread[entry_point={:X}, handle={:X}]", entry_point, *new_thread_handle));

-    system.PrepareReschedule(thread->GetProcessorID());
+    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();

    return RESULT_SUCCESS;
 }
@@ -1529,7 +1525,7 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
    thread->ResumeFromWait();

    if (thread->GetStatus() == ThreadStatus::Ready) {
-        system.PrepareReschedule(thread->GetProcessorID());
+        system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
    }

    return RESULT_SUCCESS;
@@ -1541,7 +1537,7 @@ static void ExitThread(Core::System& system) {

    auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
    current_thread->Stop();
-    system.GlobalScheduler().RemoveThread(current_thread);
+    system.CurrentScheduler().RemoveThread(current_thread);
    system.PrepareReschedule();
 }

@@ -1561,13 +1557,13 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
    if (nanoseconds <= 0) {
        switch (static_cast<SleepType>(nanoseconds)) {
        case SleepType::YieldWithoutLoadBalancing:
-            current_thread->YieldSimple();
+            scheduler.YieldWithoutLoadBalancing(current_thread);
            break;
        case SleepType::YieldWithLoadBalancing:
-            current_thread->YieldAndBalanceLoad();
+            scheduler.YieldWithLoadBalancing(current_thread);
            break;
        case SleepType::YieldAndWaitForLoadBalancing:
-            current_thread->YieldAndWaitForLoadBalancing();
+            scheduler.YieldAndWaitForLoadBalancing(current_thread);
            break;
        default:
            UNREACHABLE_MSG("Unimplemented sleep yield type '{:016X}'!", nanoseconds);
@@ -1576,7 +1572,10 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
        current_thread->Sleep(nanoseconds);
    }

-    system.PrepareReschedule(current_thread->GetProcessorID());
+    // Reschedule all CPU cores
+    for (std::size_t i = 0; i < Core::NUM_CPU_CORES; ++i) {
+        system.CpuCore(i).PrepareReschedule();
+    }
 }

 /// Wait process wide key atomic
@@ -1607,14 +1606,12 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
    ASSERT(thread);

-    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
-
-    const auto release_result =
-        current_process->GetMutex().Release(mutex_addr, current_thread.get());
+    const auto release_result = current_process->GetMutex().Release(mutex_addr);
    if (release_result.IsError()) {
        return release_result;
    }

+    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
    current_thread->SetCondVarWaitAddress(condition_variable_addr);
    current_thread->SetMutexWaitAddress(mutex_addr);
    current_thread->SetWaitHandle(thread_handle);
@@ -1625,7 +1622,7 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add

    // Note: Deliberately don't attempt to inherit the lock owner's priority.

-    system.PrepareReschedule(current_thread->GetProcessorID());
+    system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
    return RESULT_SUCCESS;
 }

@@ -1635,17 +1632,24 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
    LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
              condition_variable_addr, target);

+    const auto RetrieveWaitingThreads = [&system](std::size_t core_index,
+                                                  std::vector<SharedPtr<Thread>>& waiting_threads,
+                                                  VAddr condvar_addr) {
+        const auto& scheduler = system.Scheduler(core_index);
+        const auto& thread_list = scheduler.GetThreadList();
+
+        for (const auto& thread : thread_list) {
+            if (thread->GetCondVarWaitAddress() == condvar_addr)
+                waiting_threads.push_back(thread);
+        }
+    };
+
    // Retrieve a list of all threads that are waiting for this condition variable.
    std::vector<SharedPtr<Thread>> waiting_threads;
-    const auto& scheduler = system.GlobalScheduler();
-    const auto& thread_list = scheduler.GetThreadList();
-
-    for (const auto& thread : thread_list) {
-        if (thread->GetCondVarWaitAddress() == condition_variable_addr) {
-            waiting_threads.push_back(thread);
-        }
-    }
-
+    RetrieveWaitingThreads(0, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(1, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(2, waiting_threads, condition_variable_addr);
+    RetrieveWaitingThreads(3, waiting_threads, condition_variable_addr);
    // Sort them by priority, such that the highest priority ones come first.
    std::sort(waiting_threads.begin(), waiting_threads.end(),
              [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
@@ -1700,7 +1704,7 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
            thread->SetLockOwner(nullptr);
            thread->SetMutexWaitAddress(0);
            thread->SetWaitHandle(0);
-            system.PrepareReschedule(thread->GetProcessorID());
+            system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
        } else {
            // Atomically signal that the mutex now has a waiting thread.
            do {
@@ -1724,7 +1728,6 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
            thread->SetStatus(ThreadStatus::WaitMutex);

            owner->AddMutexWaiter(thread);
-            system.PrepareReschedule(thread->GetProcessorID());
        }
    }

@@ -1751,12 +1754,7 @@ static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type,

    const auto arbitration_type = static_cast<AddressArbiter::ArbitrationType>(type);
    auto& address_arbiter = system.Kernel().CurrentProcess()->GetAddressArbiter();
-    const ResultCode result =
-        address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
-    if (result == RESULT_SUCCESS) {
-        system.PrepareReschedule();
-    }
-    return result;
+    return address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
 }

 // Signals to an address (via Address Arbiter)
@@ -2042,10 +2040,7 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,
        return ERR_INVALID_HANDLE;
    }

-    system.PrepareReschedule(thread->GetProcessorID());
    thread->ChangeCore(core, affinity_mask);
-    system.PrepareReschedule(thread->GetProcessorID());
-
    return RESULT_SUCCESS;
 }

@@ -2156,7 +2151,6 @@ static ResultCode SignalEvent(Core::System& system, Handle handle) {
    }

    writable_event->Signal();
-    system.PrepareReschedule();
    return RESULT_SUCCESS;
 }

@@ -45,7 +45,15 @@ void Thread::Stop() {
                                                             callback_handle);
    kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
    callback_handle = 0;
-    SetStatus(ThreadStatus::Dead);
+
+    // Clean up thread from ready queue
+    // This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
+    if (status == ThreadStatus::Ready || status == ThreadStatus::Paused) {
+        scheduler->UnscheduleThread(this, current_priority);
+    }
+
+    status = ThreadStatus::Dead;
+
    WakeupAllWaitingThreads();

    // Clean up any dangling references in objects that this thread was waiting for
@@ -124,11 +132,13 @@ void Thread::ResumeFromWait() {
    wakeup_callback = nullptr;

    if (activity == ThreadActivity::Paused) {
-        SetStatus(ThreadStatus::Paused);
+        status = ThreadStatus::Paused;
        return;
    }

-    SetStatus(ThreadStatus::Ready);
+    status = ThreadStatus::Ready;
+
+    ChangeScheduler();
 }

 void Thread::CancelWait() {
@@ -195,9 +205,9 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
    thread->name = std::move(name);
    thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
    thread->owner_process = &owner_process;
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.AddThread(thread);
    thread->tls_address = thread->owner_process->CreateTLSRegion();
+    thread->scheduler = &system.Scheduler(processor_id);
+    thread->scheduler->AddThread(thread);

    thread->owner_process->RegisterThread(thread.get());

@@ -240,22 +250,6 @@ void Thread::SetStatus(ThreadStatus new_status) {
        return;
    }

-    switch (new_status) {
-    case ThreadStatus::Ready:
-    case ThreadStatus::Running:
-        SetSchedulingStatus(ThreadSchedStatus::Runnable);
-        break;
-    case ThreadStatus::Dormant:
-        SetSchedulingStatus(ThreadSchedStatus::None);
-        break;
-    case ThreadStatus::Dead:
-        SetSchedulingStatus(ThreadSchedStatus::Exited);
-        break;
-    default:
-        SetSchedulingStatus(ThreadSchedStatus::Paused);
-        break;
-    }
-
    if (status == ThreadStatus::Running) {
        last_running_ticks = Core::System::GetInstance().CoreTiming().GetTicks();
    }
@@ -317,7 +311,8 @@ void Thread::UpdatePriority() {
        return;
    }

-    SetCurrentPriority(new_priority);
+    scheduler->SetThreadPriority(this, new_priority);
+    current_priority = new_priority;

    if (!lock_owner) {
        return;
@@ -333,7 +328,47 @@ void Thread::UpdatePriority() {
 }

 void Thread::ChangeCore(u32 core, u64 mask) {
-    SetCoreAndAffinityMask(core, mask);
+    ideal_core = core;
+    affinity_mask = mask;
+    ChangeScheduler();
+}
+
+void Thread::ChangeScheduler() {
+    if (status != ThreadStatus::Ready) {
+        return;
+    }
+
+    auto& system = Core::System::GetInstance();
+    std::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
+
+    if (!new_processor_id) {
+        new_processor_id = processor_id;
+    }
+    if (ideal_core != -1 && system.Scheduler(ideal_core).GetCurrentThread() == nullptr) {
+        new_processor_id = ideal_core;
+    }
+
+    ASSERT(*new_processor_id < 4);
+
+    // Add thread to new core's scheduler
+    auto& next_scheduler = system.Scheduler(*new_processor_id);
+
+    if (*new_processor_id != processor_id) {
+        // Remove thread from previous core's scheduler
+        scheduler->RemoveThread(this);
+        next_scheduler.AddThread(this);
+    }
+
+    processor_id = *new_processor_id;
+
+    // If the thread was ready, unschedule from the previous core and schedule on the new core
+    scheduler->UnscheduleThread(this, current_priority);
+    next_scheduler.ScheduleThread(this, current_priority);
+
+    // Change thread's scheduler
+    scheduler = &next_scheduler;
+
+    system.CpuCore(processor_id).PrepareReschedule();
 }

 bool Thread::AllWaitObjectsReady() const {
@@ -356,7 +391,7 @@ void Thread::SetActivity(ThreadActivity value) {
        if (status == ThreadStatus::Ready) {
            status = ThreadStatus::Paused;
        } else if (status == ThreadStatus::Running) {
-            SetStatus(ThreadStatus::Paused);
+            status = ThreadStatus::Paused;
            Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
        }
    } else if (status == ThreadStatus::Paused) {
@@ -373,171 +408,6 @@ void Thread::Sleep(s64 nanoseconds) {
    WakeAfterDelay(nanoseconds);
 }

-void Thread::YieldSimple() {
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.YieldThread(this);
-}
-
-void Thread::YieldAndBalanceLoad() {
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.YieldThreadAndBalanceLoad(this);
-}
-
-void Thread::YieldAndWaitForLoadBalancing() {
-    auto& scheduler = kernel.GlobalScheduler();
-    scheduler.YieldThreadAndWaitForLoadBalancing(this);
-}
-
-void Thread::SetSchedulingStatus(ThreadSchedStatus new_status) {
-    const u32 old_flags = scheduling_state;
-    scheduling_state =
-        (scheduling_state & ThreadSchedMasks::HighMask) | static_cast<u32>(new_status);
-    AdjustSchedulingOnStatus(old_flags);
-}
-
-void Thread::SetCurrentPriority(u32 new_priority) {
-    u32 old_priority = std::exchange(current_priority, new_priority);
-    AdjustSchedulingOnPriority(old_priority);
-}
-
-ResultCode Thread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
-    const auto HighestSetCore = [](u64 mask, u32 max_cores) {
-        for (s32 core = max_cores - 1; core >= 0; core--) {
-            if (((mask >> core) & 1) != 0) {
-                return core;
-            }
-        }
-        return -1;
-    };
-
-    const bool use_override = affinity_override_count != 0;
-    // The value -3 is "do not change the ideal core".
-    if (new_core == -3) {
-        new_core = use_override ? ideal_core_override : ideal_core;
-        if ((new_affinity_mask & (1 << new_core)) == 0) {
-            return ERR_INVALID_COMBINATION;
-        }
-    }
-    if (use_override) {
-        ideal_core_override = new_core;
-        affinity_mask_override = new_affinity_mask;
-    } else {
-        const u64 old_affinity_mask = std::exchange(affinity_mask, new_affinity_mask);
-        ideal_core = new_core;
-        if (old_affinity_mask != new_affinity_mask) {
-            const s32 old_core = processor_id;
-            if (processor_id >= 0 && ((affinity_mask >> processor_id) & 1) == 0) {
-                if (ideal_core < 0) {
-                    processor_id = HighestSetCore(affinity_mask, GlobalScheduler::NUM_CPU_CORES);
-                } else {
-                    processor_id = ideal_core;
-                }
-            }
-            AdjustSchedulingOnAffinity(old_affinity_mask, old_core);
-        }
-    }
-    return RESULT_SUCCESS;
-}
-
-void Thread::AdjustSchedulingOnStatus(u32 old_flags) {
-    if (old_flags == scheduling_state) {
-        return;
-    }
-
-    auto& scheduler = kernel.GlobalScheduler();
-    if (static_cast<ThreadSchedStatus>(old_flags & ThreadSchedMasks::LowMask) ==
-        ThreadSchedStatus::Runnable) {
-        // In this case the thread was running, now it's pausing/exitting
-        if (processor_id >= 0) {
-            scheduler.Unschedule(current_priority, processor_id, this);
-        }
-
-        for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-            if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-                scheduler.Unsuggest(current_priority, core, this);
-            }
-        }
-    } else if (GetSchedulingStatus() == ThreadSchedStatus::Runnable) {
-        // The thread is now set to running from being stopped
-        if (processor_id >= 0) {
-            scheduler.Schedule(current_priority, processor_id, this);
-        }
-
-        for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-            if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-                scheduler.Suggest(current_priority, core, this);
-            }
-        }
-    }
-
-    scheduler.SetReselectionPending();
-}
-
-void Thread::AdjustSchedulingOnPriority(u32 old_priority) {
-    if (GetSchedulingStatus() != ThreadSchedStatus::Runnable) {
-        return;
-    }
-    auto& scheduler = Core::System::GetInstance().GlobalScheduler();
-    if (processor_id >= 0) {
-        scheduler.Unschedule(old_priority, processor_id, this);
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-            scheduler.Unsuggest(old_priority, core, this);
-        }
-    }
-
-    // Add thread to the new priority queues.
-    Thread* current_thread = GetCurrentThread();
-
-    if (processor_id >= 0) {
-        if (current_thread == this) {
-            scheduler.SchedulePrepend(current_priority, processor_id, this);
-        } else {
-            scheduler.Schedule(current_priority, processor_id, this);
-        }
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (core != processor_id && ((affinity_mask >> core) & 1) != 0) {
-            scheduler.Suggest(current_priority, core, this);
-        }
-    }
-
-    scheduler.SetReselectionPending();
-}
-
-void Thread::AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core) {
-    auto& scheduler = Core::System::GetInstance().GlobalScheduler();
-    if (GetSchedulingStatus() != ThreadSchedStatus::Runnable ||
-        current_priority >= THREADPRIO_COUNT) {
-        return;
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (((old_affinity_mask >> core) & 1) != 0) {
-            if (core == old_core) {
-                scheduler.Unschedule(current_priority, core, this);
-            } else {
-                scheduler.Unsuggest(current_priority, core, this);
-            }
-        }
-    }
-
-    for (u32 core = 0; core < GlobalScheduler::NUM_CPU_CORES; core++) {
-        if (((affinity_mask >> core) & 1) != 0) {
-            if (core == processor_id) {
-                scheduler.Schedule(current_priority, core, this);
-            } else {
-                scheduler.Suggest(current_priority, core, this);
-            }
-        }
-    }
-
-    scheduler.SetReselectionPending();
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 /**
@@ -75,26 +75,6 @@ enum class ThreadActivity : u32 {
    Paused = 1,
 };

-enum class ThreadSchedStatus : u32 {
-    None = 0,
-    Paused = 1,
-    Runnable = 2,
-    Exited = 3,
-};
-
-enum ThreadSchedFlags : u32 {
-    ProcessPauseFlag = 1 << 4,
-    ThreadPauseFlag = 1 << 5,
-    ProcessDebugPauseFlag = 1 << 6,
-    KernelInitPauseFlag = 1 << 8,
-};
-
-enum ThreadSchedMasks : u32 {
-    LowMask = 0x000f,
-    HighMask = 0xfff0,
-    ForcePauseMask = 0x0070,
-};
-
 class Thread final : public WaitObject {
 public:
    using MutexWaitingThreads = std::vector<SharedPtr<Thread>>;
@@ -298,10 +278,6 @@ public:
        return processor_id;
    }

-    void SetProcessorID(s32 new_core) {
-        processor_id = new_core;
-    }
-
    Process* GetOwnerProcess() {
        return owner_process;
    }
@@ -407,38 +383,11 @@ public:
    /// Sleeps this thread for the given amount of nanoseconds.
    void Sleep(s64 nanoseconds);

-    /// Yields this thread without rebalancing loads.
-    void YieldSimple();
-
-    /// Yields this thread and does a load rebalancing.
-    void YieldAndBalanceLoad();
-
-    /// Yields this thread and if the core is left idle, loads are rebalanced
-    void YieldAndWaitForLoadBalancing();
-
-    ThreadSchedStatus GetSchedulingStatus() const {
-        return static_cast<ThreadSchedStatus>(scheduling_state & ThreadSchedMasks::LowMask);
-    }
-
-    bool IsRunning() const {
-        return is_running;
-    }
-
-    void SetIsRunning(bool value) {
-        is_running = value;
-    }
-
 private:
    explicit Thread(KernelCore& kernel);
    ~Thread() override;

-    void SetSchedulingStatus(ThreadSchedStatus new_status);
-    void SetCurrentPriority(u32 new_priority);
-    ResultCode SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask);
-
-    void AdjustSchedulingOnStatus(u32 old_flags);
-    void AdjustSchedulingOnPriority(u32 old_priority);
-    void AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core);
+    void ChangeScheduler();

    Core::ARM_Interface::ThreadContext context{};

@@ -504,13 +453,6 @@ private:

    ThreadActivity activity = ThreadActivity::Normal;

-    s32 ideal_core_override = -1;
-    u64 affinity_mask_override = 0x1;
-    u32 affinity_override_count = 0;
-
-    u32 scheduling_state = 0;
-    bool is_running = false;
-
    std::string name;
 };

@@ -6,8 +6,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
@@ -88,7 +86,6 @@ void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
    }
    if (resume) {
        thread->ResumeFromWait();
-        Core::System::GetInstance().PrepareReschedule(thread->GetProcessorID());
    }
 }

@@ -1141,12 +1141,12 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
    if (kind == LaunchParameterKind::ApplicationSpecific && !launch_popped_application_specific) {
        const auto backend = BCAT::CreateBackendFromSettings(
            [this](u64 tid) { return system.GetFileSystemController().GetBCATDirectory(tid); });
-        const auto build_id_full = system.GetCurrentProcessBuildID();
+        const auto build_id_full = Core::System::GetInstance().GetCurrentProcessBuildID();
        u64 build_id{};
        std::memcpy(&build_id, build_id_full.data(), sizeof(u64));

        const auto data =
-            backend->GetLaunchParameter({system.CurrentProcess()->GetTitleID(), build_id});
+            backend->GetLaunchParameter({Core::CurrentProcess()->GetTitleID(), build_id});

        if (data.has_value()) {
            IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -1199,7 +1199,7 @@ void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_AM, "called, uid={:016X}{:016X}", user_id[1], user_id[0]);

    FileSys::SaveDataDescriptor descriptor{};
-    descriptor.title_id = system.CurrentProcess()->GetTitleID();
+    descriptor.title_id = Core::CurrentProcess()->GetTitleID();
    descriptor.user_id = user_id;
    descriptor.type = FileSys::SaveDataType::SaveData;
    const auto res = system.GetFileSystemController().CreateSaveData(
@@ -147,7 +147,6 @@ private:
    void GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx);
    void GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequestContext& ctx);

-    Core::System& system;
    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
    Kernel::EventPair launchable_event;
    Kernel::EventPair accumulated_suspended_tick_changed_event;
@@ -155,6 +154,8 @@ private:
    u32 idle_time_detection_extension = 0;
    u64 num_fatal_sections_entered = 0;
    bool is_auto_sleep_disabled = false;
+
+    Core::System& system;
 };

 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
@@ -13,7 +13,7 @@ constexpr PerformanceConfiguration DEFAULT_PERFORMANCE_CONFIGURATION =
    PerformanceConfiguration::Config7;

 Controller::Controller(Core::Timing::CoreTiming& core_timing)
-    : core_timing{core_timing}, configs{
+    : core_timing(core_timing), configs{
                                    {PerformanceMode::Handheld, DEFAULT_PERFORMANCE_CONFIGURATION},
                                    {PerformanceMode::Docked, DEFAULT_PERFORMANCE_CONFIGURATION},
                                } {}
@@ -63,7 +63,6 @@ PerformanceConfiguration Controller::GetCurrentPerformanceConfiguration(Performa
 void Controller::SetClockSpeed(u32 mhz) {
    LOG_INFO(Service_APM, "called, mhz={:08X}", mhz);
    // TODO(DarkLordZach): Actually signal core_timing to change clock speed.
-    // TODO(Rodrigo): Remove [[maybe_unused]] when core_timing is used.
 }

 } // namespace Service::APM
@@ -50,7 +50,7 @@ enum class PerformanceMode : u8 {
 // system during times of high load -- this simply maps to different PerformanceConfigs to use.
 class Controller {
 public:
-    explicit Controller(Core::Timing::CoreTiming& core_timing);
+    Controller(Core::Timing::CoreTiming& core_timing);
    ~Controller();

    void SetPerformanceConfiguration(PerformanceMode mode, PerformanceConfiguration config);
@@ -62,9 +62,9 @@ public:
 private:
    void SetClockSpeed(u32 mhz);

-    [[maybe_unused]] Core::Timing::CoreTiming& core_timing;
-
    std::map<PerformanceMode, PerformanceConfiguration> configs;
+
+    Core::Timing::CoreTiming& core_timing;
 };

 } // namespace Service::APM
@@ -205,7 +205,7 @@ private:
    AudioCore::StreamPtr stream;
    std::string device_name;

-    [[maybe_unused]] AudoutParams audio_params {};
+    AudoutParams audio_params{};

    /// This is the event handle used to check if the audio buffer was released
    Kernel::EventPair buffer_event;
@@ -10,14 +10,13 @@

 namespace Service::BCAT {

-ProgressServiceBackend::ProgressServiceBackend(std::string_view event_name) {
+ProgressServiceBackend::ProgressServiceBackend(std::string event_name) : impl{} {
    auto& kernel{Core::System::GetInstance().Kernel()};
    event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Automatic,
-        std::string("ProgressServiceBackend:UpdateEvent:").append(event_name));
+        kernel, Kernel::ResetType::Automatic, "ProgressServiceBackend:UpdateEvent:" + event_name);
 }

-Kernel::SharedPtr<Kernel::ReadableEvent> ProgressServiceBackend::GetEvent() const {
+Kernel::SharedPtr<Kernel::ReadableEvent> ProgressServiceBackend::GetEvent() {
    return event.readable;
 }

@@ -96,7 +95,7 @@ Backend::Backend(DirectoryGetter getter) : dir_getter(std::move(getter)) {}

 Backend::~Backend() = default;

-NullBackend::NullBackend(DirectoryGetter getter) : Backend(std::move(getter)) {}
+NullBackend::NullBackend(const DirectoryGetter& getter) : Backend(std::move(getter)) {}

 NullBackend::~NullBackend() = default;

@@ -6,9 +6,6 @@

 #include <functional>
 #include <optional>
-#include <string>
-#include <string_view>
-
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/readable_event.h"
@@ -88,14 +85,14 @@ public:
    void FinishDownload(ResultCode result);

 private:
-    explicit ProgressServiceBackend(std::string_view event_name);
+    explicit ProgressServiceBackend(std::string event_name);

-    Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent() const;
+    Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent();
    DeliveryCacheProgressImpl& GetImpl();

    void SignalUpdate() const;

-    DeliveryCacheProgressImpl impl{};
+    DeliveryCacheProgressImpl impl;
    Kernel::EventPair event;
    bool need_hle_lock = false;
 };
@@ -131,7 +128,7 @@ protected:
 // A backend of BCAT that provides no operation.
 class NullBackend : public Backend {
 public:
-    explicit NullBackend(DirectoryGetter getter);
+    explicit NullBackend(const DirectoryGetter& getter);
    ~NullBackend() override;

    bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) override;
@@ -88,7 +88,7 @@ std::ostream& operator<<(std::ostream& os, DownloadResult result) {

 constexpr u32 PORT = 443;
 constexpr u32 TIMEOUT_SECONDS = 30;
-[[maybe_unused]] constexpr u64 VFS_COPY_BLOCK_SIZE = 1ULL << 24; // 4MB
+constexpr u64 VFS_COPY_BLOCK_SIZE = 1ull << 24; // 4MB

 namespace {

@@ -495,8 +495,7 @@ Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
        }

        return StatusResult::Success;
-    } catch (const nlohmann::json::parse_error& error) {
-        LOG_ERROR(Service_BCAT, "{}", error.what());
+    } catch (const nlohmann::json::parse_error& e) {
        return StatusResult::ParseError;
    }
 }
@@ -6,9 +6,8 @@

 namespace Service::BCAT {

-BCAT::BCAT(Core::System& system, std::shared_ptr<Module> module,
-           FileSystem::FileSystemController& fsc, const char* name)
-    : Interface(system, std::move(module), fsc, name) {
+BCAT::BCAT(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc, const char* name)
+    : Module::Interface(std::move(module), fsc, name) {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &BCAT::CreateBcatService, "CreateBcatService"},
@@ -6,16 +6,12 @@

 #include "core/hle/service/bcat/module.h"

-namespace Core {
-class System;
-}
-
 namespace Service::BCAT {

 class BCAT final : public Module::Interface {
 public:
-    explicit BCAT(Core::System& system, std::shared_ptr<Module> module,
-                  FileSystem::FileSystemController& fsc, const char* name);
+    explicit BCAT(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc,
+                  const char* name);
    ~BCAT() override;
 };

@@ -35,7 +35,8 @@ using BCATDigest = std::array<u8, 0x10>;

 namespace {

-u64 GetCurrentBuildID(const Core::System::CurrentBuildProcessID& id) {
+u64 GetCurrentBuildID() {
+    const auto& id = Core::System::GetInstance().GetCurrentProcessBuildID();
    u64 out{};
    std::memcpy(&out, id.data(), sizeof(u64));
    return out;
@@ -124,8 +125,7 @@ private:

 class IBcatService final : public ServiceFramework<IBcatService> {
 public:
-    explicit IBcatService(Core::System& system_, Backend& backend_)
-        : ServiceFramework("IBcatService"), system{system_}, backend{backend_} {
+    IBcatService(Backend& backend) : ServiceFramework("IBcatService"), backend(backend) {
        // clang-format off
        static const FunctionInfo functions[] = {
            {10100, &IBcatService::RequestSyncDeliveryCache, "RequestSyncDeliveryCache"},
@@ -163,8 +163,7 @@ private:
    void RequestSyncDeliveryCache(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_BCAT, "called");

-        backend.Synchronize({system.CurrentProcess()->GetTitleID(),
-                             GetCurrentBuildID(system.GetCurrentProcessBuildID())},
+        backend.Synchronize({Core::CurrentProcess()->GetTitleID(), GetCurrentBuildID()},
                            progress.at(static_cast<std::size_t>(SyncType::Normal)));

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -180,8 +179,7 @@ private:

        LOG_DEBUG(Service_BCAT, "called, name={}", name);

-        backend.SynchronizeDirectory({system.CurrentProcess()->GetTitleID(),
-                                      GetCurrentBuildID(system.GetCurrentProcessBuildID())},
+        backend.SynchronizeDirectory({Core::CurrentProcess()->GetTitleID(), GetCurrentBuildID()},
                                     name,
                                     progress.at(static_cast<std::size_t>(SyncType::Directory)));

@@ -246,7 +244,6 @@ private:
        rb.Push(RESULT_SUCCESS);
    }

-    Core::System& system;
    Backend& backend;

    std::array<ProgressServiceBackend, static_cast<std::size_t>(SyncType::Count)> progress{
@@ -260,7 +257,7 @@ void Module::Interface::CreateBcatService(Kernel::HLERequestContext& ctx) {

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IBcatService>(system, *backend);
+    rb.PushIpcInterface<IBcatService>(*backend);
 }

 class IDeliveryCacheFileService final : public ServiceFramework<IDeliveryCacheFileService> {
@@ -454,7 +451,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u32>(write_size * sizeof(DeliveryCacheDirectoryEntry)));
+        rb.Push<u32>(write_size * sizeof(DeliveryCacheDirectoryEntry));
    }

    void GetCount(Kernel::HLERequestContext& ctx) {
@@ -471,7 +468,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u32>(files.size()));
+        rb.Push<u32>(files.size());
    }

    FileSys::VirtualDir root;
@@ -528,7 +525,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u32>(size));
+        rb.Push<u32>(size);
    }

    FileSys::VirtualDir root;
@@ -542,7 +539,7 @@ void Module::Interface::CreateDeliveryCacheStorageService(Kernel::HLERequestCont
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
    rb.PushIpcInterface<IDeliveryCacheStorageService>(
-        fsc.GetBCATDirectory(system.CurrentProcess()->GetTitleID()));
+        fsc.GetBCATDirectory(Core::CurrentProcess()->GetTitleID()));
 }

 void Module::Interface::CreateDeliveryCacheStorageServiceWithApplicationId(
@@ -568,23 +565,22 @@ std::unique_ptr<Backend> CreateBackendFromSettings(DirectoryGetter getter) {
    return std::make_unique<NullBackend>(std::move(getter));
 }

-Module::Interface::Interface(Core::System& system_, std::shared_ptr<Module> module_,
-                             FileSystem::FileSystemController& fsc_, const char* name)
-    : ServiceFramework(name), fsc{fsc_}, module{std::move(module_)},
-      backend{CreateBackendFromSettings([&fsc_](u64 tid) { return fsc_.GetBCATDirectory(tid); })},
-      system{system_} {}
+Module::Interface::Interface(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc,
+                             const char* name)
+    : ServiceFramework(name), module(std::move(module)), fsc(fsc),
+      backend(CreateBackendFromSettings([&fsc](u64 tid) { return fsc.GetBCATDirectory(tid); })) {}

 Module::Interface::~Interface() = default;

 void InstallInterfaces(Core::System& system) {
    auto module = std::make_shared<Module>();
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:a")
+    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:a")
        ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:m")
+    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:m")
        ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:u")
+    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:u")
        ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:s")
+    std::make_shared<BCAT>(module, system.GetFileSystemController(), "bcat:s")
        ->InstallAsService(system.ServiceManager());
 }

@@ -6,10 +6,6 @@

 #include "core/hle/service/service.h"

-namespace Core {
-class System;
-}
-
 namespace Service {

 namespace FileSystem {
@@ -24,8 +20,8 @@ class Module final {
 public:
    class Interface : public ServiceFramework<Interface> {
    public:
-        explicit Interface(Core::System& system_, std::shared_ptr<Module> module_,
-                           FileSystem::FileSystemController& fsc_, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, FileSystem::FileSystemController& fsc,
+                           const char* name);
        ~Interface() override;

        void CreateBcatService(Kernel::HLERequestContext& ctx);
@@ -37,9 +33,6 @@ public:

        std::shared_ptr<Module> module;
        std::unique_ptr<Backend> backend;
-
-    private:
-        Core::System& system;
    };
 };

@@ -66,7 +66,7 @@ enum class FatalType : u32 {

 static void GenerateErrorReport(Core::System& system, ResultCode error_code,
                                const FatalInfo& info) {
-    const auto title_id = system.CurrentProcess()->GetTitleID();
+    const auto title_id = Core::CurrentProcess()->GetTitleID();
    std::string crash_report = fmt::format(
        "Yuzu {}-{} crash report\n"
        "Title ID:                        {:016x}\n"
@@ -244,7 +244,7 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
    return FileSys::ERROR_PATH_NOT_FOUND;
 }

-FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}
+FileSystemController::FileSystemController() = default;

 FileSystemController::~FileSystemController() = default;

@@ -293,7 +293,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess()
        return ResultCode(-1);
    }

-    return romfs_factory->OpenCurrentProcess(system.CurrentProcess()->GetTitleID());
+    return romfs_factory->OpenCurrentProcess();
 }

 ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
@@ -450,10 +450,10 @@ FileSys::SaveDataSize FileSystemController::ReadSaveDataSize(FileSys::SaveDataTy
        FileSys::SaveDataSize new_size{SUFFICIENT_SAVE_DATA_SIZE, SUFFICIENT_SAVE_DATA_SIZE};

        FileSys::NACP nacp;
-        const auto res = system.GetAppLoader().ReadControlData(nacp);
+        const auto res = Core::System::GetInstance().GetAppLoader().ReadControlData(nacp);

        if (res != Loader::ResultStatus::Success) {
-            FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
+            FileSys::PatchManager pm{Core::CurrentProcess()->GetTitleID()};
            auto [nacp_unique, discard] = pm.GetControlMetadata();

            if (nacp_unique != nullptr) {
@@ -705,10 +705,10 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
    if (bis_factory == nullptr) {
        bis_factory =
            std::make_unique<FileSys::BISFactory>(nand_directory, load_directory, dump_directory);
-        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::SysNAND,
-                                       bis_factory->GetSystemNANDContents());
-        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::UserNAND,
-                                       bis_factory->GetUserNANDContents());
+        Core::System::GetInstance().RegisterContentProvider(
+            FileSys::ContentProviderUnionSlot::SysNAND, bis_factory->GetSystemNANDContents());
+        Core::System::GetInstance().RegisterContentProvider(
+            FileSys::ContentProviderUnionSlot::UserNAND, bis_factory->GetUserNANDContents());
    }

    if (save_data_factory == nullptr) {
@@ -717,8 +717,8 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove

    if (sdmc_factory == nullptr) {
        sdmc_factory = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
-        system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::SDMC,
-                                       sdmc_factory->GetSDMCContents());
+        Core::System::GetInstance().RegisterContentProvider(FileSys::ContentProviderUnionSlot::SDMC,
+                                                            sdmc_factory->GetSDMCContents());
    }
 }

@@ -10,10 +10,6 @@
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"

-namespace Core {
-class System;
-}
-
 namespace FileSys {
 class BISFactory;
 class RegisteredCache;
@@ -56,7 +52,7 @@ enum class ImageDirectoryId : u32 {

 class FileSystemController {
 public:
-    explicit FileSystemController(Core::System& system_);
+    FileSystemController();
    ~FileSystemController();

    ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory);
@@ -129,8 +125,6 @@ private:
    std::unique_ptr<FileSys::XCI> gamecard;
    std::unique_ptr<FileSys::RegisteredCache> gamecard_registered;
    std::unique_ptr<FileSys::PlaceholderCache> gamecard_placeholder;
-
-    Core::System& system;
 };

 void InstallInterfaces(Core::System& system);
@@ -803,7 +803,7 @@ void FSP_SRV::CreateSaveDataFileSystem(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    auto save_struct = rp.PopRaw<FileSys::SaveDataDescriptor>();
-    [[maybe_unused]] auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
+    auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
    u128 uid = rp.PopRaw<u128>();

    LOG_DEBUG(Service_FS, "called save_struct = {}, uid = {:016X}{:016X}", save_struct.DebugInfo(),
@@ -237,6 +237,7 @@ private:
    };

    Common::UUID uuid;
+    bool is_event_created = false;
    Kernel::EventPair notification_event;
    std::queue<SizedNotificationInfo> notifications;
    States states{};
@@ -11,10 +11,11 @@
 namespace Service::HID {

 constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
-[[maybe_unused]] constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
+constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
 enum class JoystickId : std::size_t { Joystick_Left, Joystick_Right };

-Controller_DebugPad::Controller_DebugPad(Core::System& system) : ControllerBase(system) {}
+Controller_DebugPad::Controller_DebugPad(Core::System& system)
+    : ControllerBase(system), system(system) {}
 Controller_DebugPad::~Controller_DebugPad() = default;

 void Controller_DebugPad::OnInit() {}
@@ -89,5 +89,6 @@ private:
        buttons;
    std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID>
        analogs;
+    Core::System& system;
 };
 } // namespace Service::HID
@@ -10,7 +10,8 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3BA00;

-Controller_Gesture::Controller_Gesture(Core::System& system) : ControllerBase(system) {}
+Controller_Gesture::Controller_Gesture(Core::System& system)
+    : ControllerBase(system), system(system) {}
 Controller_Gesture::~Controller_Gesture() = default;

 void Controller_Gesture::OnInit() {}
@@ -59,5 +59,6 @@ private:
        std::array<GestureState, 17> gesture_states;
    };
    SharedMemory shared_memory{};
+    Core::System& system;
 };
 } // namespace Service::HID
@@ -12,7 +12,8 @@ namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
 constexpr u8 KEYS_PER_BYTE = 8;

-Controller_Keyboard::Controller_Keyboard(Core::System& system) : ControllerBase(system) {}
+Controller_Keyboard::Controller_Keyboard(Core::System& system)
+    : ControllerBase(system), system(system) {}
 Controller_Keyboard::~Controller_Keyboard() = default;

 void Controller_Keyboard::OnInit() {}
@@ -53,5 +53,6 @@ private:
        keyboard_keys;
    std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeKeyboard::NumKeyboardMods>
        keyboard_mods;
+    Core::System& system;
 };
 } // namespace Service::HID
@@ -11,7 +11,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3400;

-Controller_Mouse::Controller_Mouse(Core::System& system) : ControllerBase(system) {}
+Controller_Mouse::Controller_Mouse(Core::System& system) : ControllerBase(system), system(system) {}
 Controller_Mouse::~Controller_Mouse() = default;

 void Controller_Mouse::OnInit() {}
@@ -53,5 +53,6 @@ private:
    std::unique_ptr<Input::MouseDevice> mouse_device;
    std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeMouseButton::NumMouseButtons>
        mouse_button_devices;
+    Core::System& system;
 };
 } // namespace Service::HID
@@ -20,7 +20,7 @@

 namespace Service::HID {
 constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
-[[maybe_unused]] constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
+constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
 constexpr std::size_t NPAD_OFFSET = 0x9A00;
 constexpr u32 BATTERY_FULL = 2;
 constexpr u32 MAX_NPAD_ID = 7;
@@ -105,8 +105,6 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
    controller.joy_styles.raw = 0; // Zero out
    controller.device_type.raw = 0;
    switch (controller_type) {
-    case NPadControllerType::None:
-        UNREACHABLE();
    case NPadControllerType::Handheld:
        controller.joy_styles.handheld.Assign(1);
        controller.device_type.handheld.Assign(1);
@@ -241,7 +239,7 @@ void Controller_NPad::OnRelease() {}

 void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
    const auto controller_idx = NPadIdToIndex(npad_id);
-    [[maybe_unused]] const auto controller_type = connected_controllers[controller_idx].type;
+    const auto controller_type = connected_controllers[controller_idx].type;
    if (!connected_controllers[controller_idx].is_connected) {
        return;
    }
@@ -348,8 +346,6 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
        libnx_entry.connection_status.raw = 0;

        switch (controller_type) {
-        case NPadControllerType::None:
-            UNREACHABLE();
        case NPadControllerType::Handheld:
            handheld_entry.connection_status.raw = 0;
            handheld_entry.connection_status.IsWired.Assign(1);
@@ -9,7 +9,8 @@

 namespace Service::HID {

-Controller_Stubbed::Controller_Stubbed(Core::System& system) : ControllerBase(system) {}
+Controller_Stubbed::Controller_Stubbed(Core::System& system)
+    : ControllerBase(system), system(system) {}
 Controller_Stubbed::~Controller_Stubbed() = default;

 void Controller_Stubbed::OnInit() {}
@@ -30,5 +30,6 @@ public:
 private:
    bool smart_update{};
    std::size_t common_offset{};
+    Core::System& system;
 };
 } // namespace Service::HID
@@ -13,7 +13,8 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x400;

-Controller_Touchscreen::Controller_Touchscreen(Core::System& system) : ControllerBase(system) {}
+Controller_Touchscreen::Controller_Touchscreen(Core::System& system)
+    : ControllerBase(system), system(system) {}
 Controller_Touchscreen::~Controller_Touchscreen() = default;

 void Controller_Touchscreen::OnInit() {}
@@ -69,5 +69,6 @@ private:
    TouchScreenSharedMemory shared_memory{};
    std::unique_ptr<Input::TouchDevice> touch_device;
    s64_le last_touch{};
+    Core::System& system;
 };
 } // namespace Service::HID
@@ -10,7 +10,7 @@
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3C00;

-Controller_XPad::Controller_XPad(Core::System& system) : ControllerBase(system) {}
+Controller_XPad::Controller_XPad(Core::System& system) : ControllerBase(system), system(system) {}
 Controller_XPad::~Controller_XPad() = default;

 void Controller_XPad::OnInit() {}
@@ -56,5 +56,6 @@ private:
    };
    static_assert(sizeof(SharedMemory) == 0x1000, "SharedMemory is an invalid size");
    SharedMemory shared_memory{};
+    Core::System& system;
 };
 } // namespace Service::HID
@@ -38,10 +38,8 @@ namespace Service::HID {
 // Updating period for each HID device.
 // TODO(ogniK): Find actual polling rate of hid
 constexpr s64 pad_update_ticks = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 66);
-[[maybe_unused]] constexpr s64 accelerometer_update_ticks =
-    static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 100);
-[[maybe_unused]] constexpr s64 gyroscope_update_ticks =
-    static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 100);
+constexpr s64 accelerometer_update_ticks = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 100);
+constexpr s64 gyroscope_update_ticks = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 100);
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;

 IAppletResource::IAppletResource(Core::System& system)
@@ -195,7 +193,7 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
        {101, &Hid::GetSupportedNpadStyleSet, "GetSupportedNpadStyleSet"},
        {102, &Hid::SetSupportedNpadIdType, "SetSupportedNpadIdType"},
        {103, &Hid::ActivateNpad, "ActivateNpad"},
-        {104, &Hid::DeactivateNpad, "DeactivateNpad"},
+        {104, nullptr, "DeactivateNpad"},
        {106, &Hid::AcquireNpadStyleSetUpdateEventHandle, "AcquireNpadStyleSetUpdateEventHandle"},
        {107, &Hid::DisconnectNpad, "DisconnectNpad"},
        {108, &Hid::GetPlayerLedPattern, "GetPlayerLedPattern"},
@@ -470,17 +468,6 @@ void Hid::ActivateNpad(Kernel::HLERequestContext& ctx) {
    applet_resource->ActivateController(HidController::NPad);
 }

-void Hid::DeactivateNpad(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-    applet_resource->DeactivateController(HidController::NPad);
-}
-
 void Hid::AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto npad_id{rp.Pop<u32>()};
@@ -99,7 +99,6 @@ private:
    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
    void SetSupportedNpadIdType(Kernel::HLERequestContext& ctx);
    void ActivateNpad(Kernel::HLERequestContext& ctx);
-    void DeactivateNpad(Kernel::HLERequestContext& ctx);
    void AcquireNpadStyleSetUpdateEventHandle(Kernel::HLERequestContext& ctx);
    void DisconnectNpad(Kernel::HLERequestContext& ctx);
    void GetPlayerLedPattern(Kernel::HLERequestContext& ctx);
@@ -163,7 +163,7 @@ public:
            return;
        }

-        if (system.CurrentProcess()->GetTitleID() != header.title_id) {
+        if (Core::CurrentProcess()->GetTitleID() != header.title_id) {
            LOG_ERROR(Service_LDR,
                      "Attempting to load NRR with title ID other than current process. (actual "
                      "{:016X})!",
@@ -327,7 +327,7 @@ public:
        }

        // Load NRO as new executable module
-        auto* process = system.CurrentProcess();
+        auto* process = Core::CurrentProcess();
        auto& vm_manager = process->VMManager();
        auto map_address = vm_manager.FindFreeRegion(nro_size + bss_size);

@@ -411,7 +411,7 @@ public:
            return;
        }

-        auto& vm_manager = system.CurrentProcess()->VMManager();
+        auto& vm_manager = Core::CurrentProcess()->VMManager();
        const auto& nro_info = iter->second;

        // Unmap the mirrored memory
@@ -6,10 +6,8 @@
 #include <string>

 #include "common/logging/log.h"
-#include "common/scope_exit.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/lm/lm.h"
-#include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/memory.h"

@@ -17,16 +15,65 @@ namespace Service::LM {

 class ILogger final : public ServiceFramework<ILogger> {
 public:
-    ILogger(Manager& manager) : ServiceFramework("ILogger"), manager(manager) {
+    ILogger() : ServiceFramework("ILogger") {
        static const FunctionInfo functions[] = {
-            {0, &ILogger::Log, "Log"},
-            {1, &ILogger::SetDestination, "SetDestination"},
+            {0x00000000, &ILogger::Initialize, "Initialize"},
+            {0x00000001, &ILogger::SetDestination, "SetDestination"},
        };
        RegisterHandlers(functions);
    }

 private:
-    void Log(Kernel::HLERequestContext& ctx) {
+    struct MessageHeader {
+        enum Flags : u32_le {
+            IsHead = 1,
+            IsTail = 2,
+        };
+        enum Severity : u32_le {
+            Trace,
+            Info,
+            Warning,
+            Error,
+            Critical,
+        };
+
+        u64_le pid;
+        u64_le threadContext;
+        union {
+            BitField<0, 16, Flags> flags;
+            BitField<16, 8, Severity> severity;
+            BitField<24, 8, u32> verbosity;
+        };
+        u32_le payload_size;
+
+        bool IsHeadLog() const {
+            return flags & Flags::IsHead;
+        }
+        bool IsTailLog() const {
+            return flags & Flags::IsTail;
+        }
+    };
+    static_assert(sizeof(MessageHeader) == 0x18, "MessageHeader is incorrect size");
+
+    /// Log field type
+    enum class Field : u8 {
+        Skip = 1,
+        Message = 2,
+        Line = 3,
+        Filename = 4,
+        Function = 5,
+        Module = 6,
+        Thread = 7,
+    };
+
+    /**
+     * ILogger::Initialize service function
+     *  Inputs:
+     *      0: 0x00000000
+     *  Outputs:
+     *      0: ResultCode
+     */
+    void Initialize(Kernel::HLERequestContext& ctx) {
        // This function only succeeds - Get that out of the way
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
@@ -38,70 +85,140 @@ private:
        Memory::ReadBlock(addr, &header, sizeof(MessageHeader));
        addr += sizeof(MessageHeader);

-        FieldMap fields;
+        if (header.IsHeadLog()) {
+            log_stream.str("");
+            log_stream.clear();
+        }
+
+        // Parse out log metadata
+        u32 line{};
+        std::string module;
+        std::string message;
+        std::string filename;
+        std::string function;
+        std::string thread;
        while (addr < end_addr) {
-            const auto field = static_cast<Field>(Memory::Read8(addr++));
-            const auto length = Memory::Read8(addr++);
+            const Field field{static_cast<Field>(Memory::Read8(addr++))};
+            const std::size_t length{Memory::Read8(addr++)};

            if (static_cast<Field>(Memory::Read8(addr)) == Field::Skip) {
                ++addr;
            }

-            SCOPE_EXIT({ addr += length; });
-
-            if (field == Field::Skip) {
-                continue;
+            switch (field) {
+            case Field::Skip:
+                break;
+            case Field::Message:
+                message = Memory::ReadCString(addr, length);
+                break;
+            case Field::Line:
+                line = Memory::Read32(addr);
+                break;
+            case Field::Filename:
+                filename = Memory::ReadCString(addr, length);
+                break;
+            case Field::Function:
+                function = Memory::ReadCString(addr, length);
+                break;
+            case Field::Module:
+                module = Memory::ReadCString(addr, length);
+                break;
+            case Field::Thread:
+                thread = Memory::ReadCString(addr, length);
+                break;
            }

-            std::vector<u8> data(length);
-            Memory::ReadBlock(addr, data.data(), length);
-            fields.emplace(field, std::move(data));
+            addr += length;
        }

-        manager.Log({header, std::move(fields)});
+        // Empty log - nothing to do here
+        if (log_stream.str().empty() && message.empty()) {
+            return;
+        }
+
+        // Format a nicely printable string out of the log metadata
+        if (!filename.empty()) {
+            log_stream << filename << ':';
+        }
+        if (!module.empty()) {
+            log_stream << module << ':';
+        }
+        if (!function.empty()) {
+            log_stream << function << ':';
+        }
+        if (line) {
+            log_stream << std::to_string(line) << ':';
+        }
+        if (!thread.empty()) {
+            log_stream << thread << ':';
+        }
+        if (log_stream.str().length() > 0 && log_stream.str().back() == ':') {
+            log_stream << ' ';
+        }
+        log_stream << message;
+
+        if (header.IsTailLog()) {
+            switch (header.severity) {
+            case MessageHeader::Severity::Trace:
+                LOG_DEBUG(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Info:
+                LOG_INFO(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Warning:
+                LOG_WARNING(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Error:
+                LOG_ERROR(Debug_Emulated, "{}", log_stream.str());
+                break;
+            case MessageHeader::Severity::Critical:
+                LOG_CRITICAL(Debug_Emulated, "{}", log_stream.str());
+                break;
+            }
+        }
    }

+    // This service function is intended to be used as a way to
+    // redirect logging output to different destinations, however,
+    // given we always want to see the logging output, it's sufficient
+    // to do nothing and return success here.
    void SetDestination(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto destination = rp.PopEnum<DestinationFlag>();
-
-        LOG_DEBUG(Service_LM, "called, destination={:08X}", static_cast<u32>(destination));
-
-        manager.SetDestination(destination);
+        LOG_DEBUG(Service_LM, "called");

        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
    }

-    Manager& manager;
+    std::ostringstream log_stream;
 };

 class LM final : public ServiceFramework<LM> {
 public:
-    explicit LM(Manager& manager) : ServiceFramework{"lm"}, manager(manager) {
-        // clang-format off
+    explicit LM() : ServiceFramework{"lm"} {
        static const FunctionInfo functions[] = {
-            {0, &LM::OpenLogger, "OpenLogger"},
+            {0x00000000, &LM::OpenLogger, "OpenLogger"},
        };
-        // clang-format on
-
        RegisterHandlers(functions);
    }

-private:
+    /**
+     * LM::OpenLogger service function
+     *  Inputs:
+     *      0: 0x00000000
+     *  Outputs:
+     *      0: ResultCode
+     */
    void OpenLogger(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_LM, "called");

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILogger>(manager);
+        rb.PushIpcInterface<ILogger>();
    }
-
-    Manager& manager;
 };

-void InstallInterfaces(Core::System& system) {
-    std::make_shared<LM>(system.GetLogManager())->InstallAsService(system.ServiceManager());
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<LM>()->InstallAsService(service_manager);
 }

 } // namespace Service::LM
@@ -4,13 +4,13 @@

 #pragma once

-namespace Core {
-class System;
+namespace Service::SM {
+class ServiceManager;
 }

 namespace Service::LM {

 /// Registers all LM services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);

 } // namespace Service::LM
@@ -1,133 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/hle/service/lm/manager.h"
-#include "core/reporter.h"
-
-namespace Service::LM {
-
-std::ostream& operator<<(std::ostream& os, DestinationFlag dest) {
-    std::vector<std::string> array;
-    const auto check_single_flag = [dest, &array](DestinationFlag check, std::string name) {
-        if ((static_cast<u32>(check) & static_cast<u32>(dest)) != 0) {
-            array.emplace_back(std::move(name));
-        }
-    };
-
-    check_single_flag(DestinationFlag::Default, "Default");
-    check_single_flag(DestinationFlag::UART, "UART");
-    check_single_flag(DestinationFlag::UARTSleeping, "UART (Sleeping)");
-
-    os << "[";
-    for (const auto& entry : array) {
-        os << entry << ", ";
-    }
-    return os << "]";
-}
-
-std::ostream& operator<<(std::ostream& os, MessageHeader::Severity severity) {
-    switch (severity) {
-    case MessageHeader::Severity::Trace:
-        return os << "Trace";
-    case MessageHeader::Severity::Info:
-        return os << "Info";
-    case MessageHeader::Severity::Warning:
-        return os << "Warning";
-    case MessageHeader::Severity::Error:
-        return os << "Error";
-    case MessageHeader::Severity::Critical:
-        return os << "Critical";
-    default:
-        return os << fmt::format("{:08X}", static_cast<u32>(severity));
-    }
-}
-
-std::ostream& operator<<(std::ostream& os, Field field) {
-    switch (field) {
-    case Field::Skip:
-        return os << "Skip";
-    case Field::Message:
-        return os << "Message";
-    case Field::Line:
-        return os << "Line";
-    case Field::Filename:
-        return os << "Filename";
-    case Field::Function:
-        return os << "Function";
-    case Field::Module:
-        return os << "Module";
-    case Field::Thread:
-        return os << "Thread";
-    default:
-        return os << fmt::format("{:08X}", static_cast<u32>(field));
-    }
-}
-
-std::string FormatField(Field type, const std::vector<u8>& data) {
-    switch (type) {
-    case Field::Skip:
-        return "";
-    case Field::Line:
-        if (data.size() >= sizeof(u32)) {
-            u32 line;
-            std::memcpy(&line, data.data(), sizeof(u32));
-            return fmt::format("{}", line);
-        }
-        return "[ERROR DECODING LINE NUMBER]";
-    case Field::Message:
-    case Field::Filename:
-    case Field::Function:
-    case Field::Module:
-    case Field::Thread:
-        return Common::StringFromFixedZeroTerminatedBuffer(
-            reinterpret_cast<const char*>(data.data()), data.size());
-    default:
-        UNIMPLEMENTED();
-    }
-}
-
-Manager::Manager(Core::Reporter& reporter) : reporter(reporter) {}
-
-Manager::~Manager() = default;
-
-void Manager::SetEnabled(bool enabled) {
-    this->enabled = enabled;
-}
-
-void Manager::SetDestination(DestinationFlag destination) {
-    this->destination = destination;
-}
-
-void Manager::Log(LogMessage message) {
-    if (message.header.IsHeadLog()) {
-        InitializeLog();
-    }
-
-    current_log.emplace_back(std::move(message));
-
-    if (current_log.back().header.IsTailLog()) {
-        FinalizeLog();
-    }
-}
-
-void Manager::Flush() {
-    FinalizeLog();
-}
-
-void Manager::InitializeLog() {
-    current_log.clear();
-
-    LOG_INFO(Service_LM, "Initialized new log session");
-}
-
-void Manager::FinalizeLog() {
-    reporter.SaveLogReport(static_cast<u32>(destination), std::move(current_log));
-
-    LOG_INFO(Service_LM, "Finalized current log session");
-}
-
-} // namespace Service::LM
@@ -1,106 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include <ostream>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-
-namespace Core {
-class Reporter;
-}
-
-namespace Service::LM {
-
-enum class DestinationFlag : u32 {
-    Default = 1,
-    UART = 2,
-    UARTSleeping = 4,
-
-    All = 0xFFFF,
-};
-
-struct MessageHeader {
-    enum Flags : u32_le {
-        IsHead = 1,
-        IsTail = 2,
-    };
-    enum Severity : u32_le {
-        Trace,
-        Info,
-        Warning,
-        Error,
-        Critical,
-    };
-
-    u64_le pid;
-    u64_le thread_context;
-    union {
-        BitField<0, 16, Flags> flags;
-        BitField<16, 8, Severity> severity;
-        BitField<24, 8, u32> verbosity;
-    };
-    u32_le payload_size;
-
-    bool IsHeadLog() const {
-        return flags & IsHead;
-    }
-    bool IsTailLog() const {
-        return flags & IsTail;
-    }
-};
-static_assert(sizeof(MessageHeader) == 0x18, "MessageHeader is incorrect size");
-
-enum class Field : u8 {
-    Skip = 1,
-    Message = 2,
-    Line = 3,
-    Filename = 4,
-    Function = 5,
-    Module = 6,
-    Thread = 7,
-};
-
-std::ostream& operator<<(std::ostream& os, DestinationFlag dest);
-std::ostream& operator<<(std::ostream& os, MessageHeader::Severity severity);
-std::ostream& operator<<(std::ostream& os, Field field);
-
-using FieldMap = std::map<Field, std::vector<u8>>;
-
-struct LogMessage {
-    MessageHeader header;
-    FieldMap fields;
-};
-
-std::string FormatField(Field type, const std::vector<u8>& data);
-
-class Manager {
-public:
-    explicit Manager(Core::Reporter& reporter);
-    ~Manager();
-
-    void SetEnabled(bool enabled);
-    void SetDestination(DestinationFlag destination);
-
-    void Log(LogMessage message);
-
-    void Flush();
-
-private:
-    void InitializeLog();
-    void FinalizeLog();
-
-    bool enabled = true;
-    DestinationFlag destination = DestinationFlag::All;
-
-    std::vector<LogMessage> current_log;
-
-    Core::Reporter& reporter;
-};
-
-} // namespace Service::LM
@@ -18,8 +18,8 @@
 namespace Service::NFP {

 namespace ErrCodes {
-[[maybe_unused]] constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
-                                                     -1); // TODO(ogniK): Find the actual error code
+constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
+                                    -1); // TODO(ogniK): Find the actual error code
 constexpr ResultCode ERR_NO_APPLICATION_AREA(ErrorModule::NFP, 152);
 } // namespace ErrCodes

@@ -35,7 +35,7 @@ Module::Interface::~Interface() = default;
 class IUser final : public ServiceFramework<IUser> {
 public:
    IUser(Module::Interface& nfp_interface, Core::System& system)
-        : ServiceFramework("NFP::IUser"), nfp_interface(nfp_interface) {
+        : ServiceFramework("NFP::IUser"), nfp_interface(nfp_interface), system(system) {
        static const FunctionInfo functions[] = {
            {0, &IUser::Initialize, "Initialize"},
            {1, &IUser::Finalize, "Finalize"},
@@ -183,8 +183,6 @@ private:
        case DeviceState::TagRemoved:
            device_state = DeviceState::Initialized;
            break;
-        default:
-            break;
        }
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_SUCCESS);
@@ -326,6 +324,7 @@ private:
    Kernel::EventPair deactivate_event;
    Kernel::EventPair availability_change_event;
    const Module::Interface& nfp_interface;
+    Core::System& system;
 };

 void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {
@@ -9,7 +9,6 @@
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/service.h"
-#include "core/settings.h"

 namespace Service::NIFM {

@@ -89,12 +88,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-
-        if (Settings::values.bcat_backend == "none") {
-            rb.PushEnum(RequestState::NotSubmitted);
-        } else {
-            rb.PushEnum(RequestState::Connected);
-        }
+        rb.PushEnum(RequestState::Connected);
    }

    void GetResult(Kernel::HLERequestContext& ctx) {
@@ -202,22 +196,14 @@ private:

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        if (Settings::values.bcat_backend == "none") {
-            rb.Push<u8>(0);
-        } else {
-            rb.Push<u8>(1);
-        }
+        rb.Push<u8>(1);
    }
    void IsAnyInternetRequestAccepted(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_NIFM, "(STUBBED) called");

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
-        if (Settings::values.bcat_backend == "none") {
-            rb.Push<u8>(0);
-        } else {
-            rb.Push<u8>(1);
-        }
+        rb.Push<u8>(1);
    }
    Core::System& system;
 };
@@ -324,14 +324,14 @@ void PL_U::GetSharedMemoryAddressOffset(Kernel::HLERequestContext& ctx) {
 void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
    // Map backing memory for the font data
    LOG_DEBUG(Service_NS, "called");
-    system.CurrentProcess()->VMManager().MapMemoryBlock(SHARED_FONT_MEM_VADDR, impl->shared_font, 0,
-                                                        SHARED_FONT_MEM_SIZE,
-                                                        Kernel::MemoryState::Shared);
+    Core::CurrentProcess()->VMManager().MapMemoryBlock(SHARED_FONT_MEM_VADDR, impl->shared_font, 0,
+                                                       SHARED_FONT_MEM_SIZE,
+                                                       Kernel::MemoryState::Shared);

    // Create shared font memory object
    auto& kernel = system.Kernel();
    impl->shared_font_mem = Kernel::SharedMemory::Create(
-        kernel, system.CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
+        kernel, Core::CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
        Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
        "PL_U:shared_font_mem");

@@ -45,8 +45,6 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std:
        return GetVARegions(input, output);
    case IoctlCommand::IocUnmapBufferCommand:
        return UnmapBuffer(input, output);
-    default:
-        break;
    }

    if (static_cast<IoctlCommand>(command.cmd.Value()) == IoctlCommand::IocRemapCommand)
@@ -38,10 +38,9 @@ u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, const std::v
        return IocCtrlEventUnregister(input, output);
    case IoctlCommand::IocCtrlEventSignalCommand:
        return IocCtrlEventSignal(input, output);
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented ioctl");
-        return 0;
    }
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
 }

 u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output) {
@@ -40,10 +40,9 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input,
        return FlushL2(input, output);
    case IoctlCommand::IocGetGpuTime:
        return GetGpuTime(input, output);
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented ioctl");
-        return 0;
    }
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
 }

 u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
@@ -44,8 +44,6 @@ u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std::ve
        return GetWaitbase(input, output);
    case IoctlCommand::IocChannelSetTimeoutCommand:
        return ChannelSetTimeout(input, output);
-    default:
-        break;
    }

    if (command.group == NVGPU_IOCTL_MAGIC) {
@@ -226,7 +226,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
    LBL::InstallInterfaces(*sm);
    LDN::InstallInterfaces(*sm);
    LDR::InstallInterfaces(*sm, system);
-    LM::InstallInterfaces(system);
+    LM::InstallInterfaces(*sm);
    Migration::InstallInterfaces(*sm);
    Mii::InstallInterfaces(*sm);
    MM::InstallInterfaces(*sm);
@@ -146,7 +146,7 @@ static u8* GetPointerFromVMA(const Kernel::Process& process, VAddr vaddr) {
 * using a VMA from the current process.
 */
 static u8* GetPointerFromVMA(VAddr vaddr) {
-    return GetPointerFromVMA(*Core::System::GetInstance().CurrentProcess(), vaddr);
+    return GetPointerFromVMA(*Core::CurrentProcess(), vaddr);
 }

 template <typename T>
@@ -226,7 +226,7 @@ bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr) {
 }

 bool IsValidVirtualAddress(const VAddr vaddr) {
-    return IsValidVirtualAddress(*Core::System::GetInstance().CurrentProcess(), vaddr);
+    return IsValidVirtualAddress(*Core::CurrentProcess(), vaddr);
 }

 bool IsKernelVirtualAddress(const VAddr vaddr) {
@@ -387,7 +387,7 @@ void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_
 }

 void ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-    ReadBlock(*Core::System::GetInstance().CurrentProcess(), src_addr, dest_buffer, size);
+    ReadBlock(*Core::CurrentProcess(), src_addr, dest_buffer, size);
 }

 void Write8(const VAddr addr, const u8 data) {
@@ -450,7 +450,7 @@ void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const voi
 }

 void WriteBlock(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-    WriteBlock(*Core::System::GetInstance().CurrentProcess(), dest_addr, src_buffer, size);
+    WriteBlock(*Core::CurrentProcess(), dest_addr, src_buffer, size);
 }

 void ZeroBlock(const Kernel::Process& process, const VAddr dest_addr, const std::size_t size) {
@@ -539,7 +539,7 @@ void CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
 }

 void CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size) {
-    CopyBlock(*Core::System::GetInstance().CurrentProcess(), dest_addr, src_addr, size);
+    CopyBlock(*Core::CurrentProcess(), dest_addr, src_addr, size);
 }

 } // namespace Memory
@@ -7,7 +7,6 @@

 #include <fmt/chrono.h>
 #include <fmt/format.h>
-#include <fmt/ostream.h>
 #include <json.hpp>

 #include "common/file_util.h"
@@ -18,7 +17,6 @@
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
-#include "core/hle/service/lm/manager.h"
 #include "core/reporter.h"
 #include "core/settings.h"

@@ -356,55 +354,6 @@ void Reporter::SaveErrorReport(u64 title_id, ResultCode result,
    SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp));
 }

-void Reporter::SaveLogReport(u32 destination, std::vector<Service::LM::LogMessage> messages) const {
-    if (!IsReportingEnabled()) {
-        return;
-    }
-
-    const auto timestamp = GetTimestamp();
-    json out;
-
-    out["yuzu_version"] = GetYuzuVersionData();
-    out["report_common"] =
-        GetReportCommonData(system.CurrentProcess()->GetTitleID(), RESULT_SUCCESS, timestamp);
-
-    out["log_destination"] =
-        fmt::format("{}", static_cast<Service::LM::DestinationFlag>(destination));
-
-    auto json_messages = json::array();
-    std::transform(messages.begin(), messages.end(), std::back_inserter(json_messages),
-                   [](const Service::LM::LogMessage& message) {
-                       json out;
-                       out["is_head"] = fmt::format("{}", message.header.IsHeadLog());
-                       out["is_tail"] = fmt::format("{}", message.header.IsTailLog());
-                       out["pid"] = fmt::format("{:016X}", message.header.pid);
-                       out["thread_context"] =
-                           fmt::format("{:016X}", message.header.thread_context);
-                       out["payload_size"] = fmt::format("{:016X}", message.header.payload_size);
-                       out["flags"] = fmt::format("{:04X}", message.header.flags.Value());
-                       out["severity"] = fmt::format("{}", message.header.severity.Value());
-                       out["verbosity"] = fmt::format("{:02X}", message.header.verbosity);
-
-                       auto fields = json::array();
-                       std::transform(message.fields.begin(), message.fields.end(),
-                                      std::back_inserter(fields), [](const auto& kv) {
-                                          json out;
-                                          out["type"] = fmt::format("{}", kv.first);
-                                          out["data"] =
-                                              Service::LM::FormatField(kv.first, kv.second);
-                                          return out;
-                                      });
-
-                       out["fields"] = std::move(fields);
-                       return out;
-                   });
-
-    out["log_messages"] = std::move(json_messages);
-
-    SaveToFile(std::move(out),
-               GetPath("log_report", system.CurrentProcess()->GetTitleID(), timestamp));
-}
-
 void Reporter::SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
                                          std::string log_message) const {
    if (!IsReportingEnabled())
Author	SHA1	Message	Date
yuzubot	854ed9a9c1	"Merge Tagged PR 1012"	2019-10-03 12:01:21 +00:00
yuzubot	ab503718e0	"Merge Tagged PR 1340"	2019-10-03 12:01:20 +00:00
yuzubot	095b60c315	"Merge Tagged PR 1703"	2019-10-03 12:01:19 +00:00
yuzubot	9b07c7c648	"Merge Tagged PR 2542"	2019-10-03 12:01:18 +00:00
yuzubot	679c81d0b5	"Merge Tagged PR 2710"	2019-10-03 12:01:17 +00:00
yuzubot	23dd00af19	"Merge Tagged PR 2859"	2019-10-03 12:01:16 +00:00
yuzubot	30980b82a4	"Merge Tagged PR 2912"	2019-10-03 12:01:16 +00:00
yuzubot	f1ec96da7a	"Merge Tagged PR 2914"	2019-10-03 12:01:15 +00:00
yuzubot	18cc4afcda	"Merge Tagged PR 2917"	2019-10-03 12:01:14 +00:00
yuzubot	13c5b0262c	"Merge Tagged PR 2927"	2019-10-03 12:01:13 +00:00