"Merge Tagged PR 1012"

Port citra-emu/citra#4930: "Pause when in background"

.ci/scripts/linux/docker.sh

@@ -5,10 +5,11 @@ cd /yuzu
 ccache -s
 
 mkdir build || true && cd build
-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
+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
 
 ninja
 
 ccache -s
 
-ctest -VV -C Release
+# Ignore zlib's tests, since they aren't gated behind a CMake option.
+ctest -VV -E "(example|example64)" -C Release

.ci/scripts/linux/exec.sh

@@ -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
+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

.ci/scripts/merge/apply-patches-by-label-private.py

@@ -0,0 +1,45 @@
+# Download all pull requests as patches that match a specific label
+# Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>
+
+import requests, sys, json, shutil, subprocess, os, traceback
+
+org = os.getenv("PRIVATEMERGEORG", "yuzu-emu")
+repo = os.getenv("PRIVATEMERGEREPO", "yuzu-private")
+tagline = sys.argv[3]
+user = sys.argv[1]
+
+dl_list = {}
+
+TAG_NAME = sys.argv[2]
+
+def check_individual(repo_id, pr_id):
+    url = 'https://%sdev.azure.com/%s/%s/_apis/git/repositories/%s/pullRequests/%s/labels?api-version=5.1-preview.1' % (user, org, repo, repo_id, pr_id)
+    response = requests.get(url)
+    if (response.ok):
+        try:
+            js = response.json()
+            return any(tag.get('name') == TAG_NAME for tag in js['value'])
+        except:
+            return False
+    return False
+
+def merge_pr(pn, ref):
+    print("Matched PR# %s" % pn)
+    print(subprocess.check_output(["git", "fetch", "https://%sdev.azure.com/%s/_git/%s" % (user, org, repo), ref, "-f"]))
+    print(subprocess.check_output(["git", "merge", "--squash", 'origin/' + ref.replace('refs/heads/','')]))
+    print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
+
+def main():
+    url = 'https://%sdev.azure.com/%s/%s/_apis/git/pullrequests?api-version=5.1' % (user, org, repo)
+    response = requests.get(url)
+    if (response.ok):
+        js = response.json()
+        tagged_prs = filter(lambda pr: check_individual(pr['repository']['id'], pr['pullRequestId']), js['value'])
+        map(lambda pr: merge_pr(pr['pullRequestId'], pr['sourceRefName']), tagged_prs)
+
+if __name__ == '__main__':
+    try:
+        main()
+    except:
+        traceback.print_exc(file=sys.stdout)
+        sys.exit(-1)

.ci/scripts/merge/apply-patches-by-label.py

@@ -1,7 +1,9 @@
 # Download all pull requests as patches that match a specific label
 # Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>
 
-import requests, sys, json, urllib3.request, shutil, subprocess
+import requests, sys, json, urllib3.request, shutil, subprocess, os
+
+tagline = sys.argv[2]
 
 http = urllib3.PoolManager()
 dl_list = {}
@@ -12,17 +14,23 @@ def check_individual(labels):
             return True
     return False
 
-try:
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls'
+def do_page(page):
+    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls?page=%s' % page
     response = requests.get(url)
     if (response.ok):
         j = json.loads(response.content)
+        if j == []:
+            return
         for pr in j:
             if (check_individual(pr["labels"])):
                 pn = pr["number"]
                 print("Matched PR# %s" % pn)
                 print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f"]))
                 print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
-                print(subprocess.check_output(["git", "commit", "-m\"Merge PR %s\"" % pn]))
+                print(subprocess.check_output(["git", "commit", "-m\"Merge %s PR %s\"" % (tagline, pn)]))
+
+try:
+    for i in range(1,30):
+        do_page(i)
 except:
     sys.exit(-1)

.ci/scripts/windows/docker.sh

@@ -13,7 +13,7 @@ echo '' >> /bin/cmd
 chmod +x /bin/cmd
 
 mkdir build || true && cd build
-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
+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
 ninja
 
 # Clean up the dirty hacks

.ci/scripts/windows/exec.sh

@@ -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
+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

.ci/scripts/windows/upload.ps1

@@ -0,0 +1,38 @@
+$GITDATE = $(git show -s --date=short --format='%ad') -replace "-",""
+$GITREV = $(git show -s --format='%h')
+$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
+$env:BUILD_UPDATE = $MSVC_SEVENZIP
+
+$BUILD_DIR = ".\build\bin\Release"
+
+mkdir pdb
+Get-ChildItem "$BUILD_DIR\" -Recurse -Filter "*.pdb" | Copy-Item -destination .\pdb
+7z a -tzip $MSVC_BUILD_PDB .\pdb\*.pdb
+rm "$BUILD_DIR\*.pdb"
+mkdir $RELEASE_DIST
+mkdir "artifacts"
+
+Copy-Item "$BUILD_DIR\*" -Destination $RELEASE_DIST -Recurse
+rm "$RELEASE_DIST\*.exe"
+Get-ChildItem "$BUILD_DIR" -Recurse -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
+Get-ChildItem "$BUILD_DIR" -Recurse -Filter "QtWebEngineProcess*.exe" | Copy-Item -destination $RELEASE_DIST
+Copy-Item .\license.txt -Destination $RELEASE_DIST
+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"

.ci/templates/build-mock.yml

@@ -0,0 +1,5 @@
+steps:
+  - script: mkdir artifacts || echo 'X' > artifacts/T1.txt
+  - publish: artifacts
+    artifact: 'yuzu-$(BuildName)-mock'
+    displayName: 'Upload Artifacts'

.ci/templates/build-msvc.yml

@@ -0,0 +1,22 @@
+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 ..
+  displayName: 'Configure CMake'
+- task: MSBuild@1
+  displayName: 'Build'
+  inputs:
+    solution: 'build/yuzu.sln'
+    maximumCpuCount: true
+    configuration: release
+- task: PowerShell@2
+  displayName: 'Package Artifacts'
+  inputs:
+    targetType: 'filePath'
+    filePath: './.ci/scripts/windows/upload.ps1'
+- publish: artifacts
+  artifact: 'yuzu-$(BuildName)-windows-msvc'
+  displayName: 'Upload Artifacts'

.ci/templates/build-single.yml

@@ -1,20 +1,20 @@
 parameters:
   artifactSource: 'true'
   cache: 'false'
+  version: ''
 
 steps:
 - task: DockerInstaller@0
   displayName: 'Prepare Environment'
   inputs:
     dockerVersion: '17.09.0-ce'
-- ${{ if eq(parameters.cache, 'true') }}:
-  - task: CacheBeta@0
-    displayName: 'Cache Build System'
-    inputs:
-      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
+- task: CacheBeta@0
+  displayName: 'Cache Build System'
+  inputs:
+    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'] }}
   displayName: 'Build'
 - script: chmod a+x ./.ci/scripts/$(ScriptFolder)/upload.sh && RELEASE_NAME=$(BuildName) ./.ci/scripts/$(ScriptFolder)/upload.sh
   displayName: 'Package Artifacts'

.ci/templates/build-standard.yml

@@ -1,3 +1,6 @@
+parameters:
+  version: ''
+
 jobs:
 - job: build
   displayName: 'standard'
@@ -20,4 +23,5 @@ jobs:
   - template: ./build-single.yml
     parameters:
       artifactSource: 'false'
-      cache: $(parameters.cache)
+      cache: $(parameters.cache)
+      version: $(parameters.version)

.ci/templates/build-testing.yml

@@ -1,3 +1,6 @@
+parameters:
+  version: ''
+
 jobs:
 - job: build_test
   displayName: 'testing'
@@ -31,3 +34,4 @@ jobs:
       parameters:
         artifactSource: 'false'
         cache: 'false'
+        version: $(parameters.version)

.ci/templates/merge-private.yml

@@ -0,0 +1,37 @@
+jobs:
+- job: merge
+  displayName: 'pull requests'
+  steps:
+  - checkout: self
+    submodules: recursive
+  - template: ./mergebot-private.yml
+    parameters:
+      matchLabel: '$(BuildName)-merge'
+      matchLabelPublic: '$(PublicBuildName)-merge'
+  - task: ArchiveFiles@2
+    displayName: 'Package Source'
+    inputs:
+      rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
+      includeRootFolder: false
+      archiveType: '7z'
+      archiveFile: '$(Build.ArtifactStagingDirectory)/yuzu-$(BuildName)-source.7z'
+  - task: PublishPipelineArtifact@1
+    displayName: 'Upload Artifacts'
+    inputs:
+      targetPath: '$(Build.ArtifactStagingDirectory)/yuzu-$(BuildName)-source.7z'
+      artifact: 'yuzu-$(BuildName)-source'
+      replaceExistingArchive: true
+- job: upload_source
+  displayName: 'upload'
+  dependsOn: merge
+  steps:
+  - template: ./sync-source.yml
+    parameters:
+      artifactSource: 'true'
+      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 remote add other $(GitRepoPushChangesURL)
+    displayName: 'Register Repository'
+  - script: git push --force other HEAD:$(GitPushBranch)
+    displayName: 'Update Code'

.ci/templates/merge.yml

@@ -30,17 +30,7 @@ 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 --follow-tags --force other HEAD:$(GitPushBranch)
+  - script: git push --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

.ci/templates/mergebot-private.yml

@@ -0,0 +1,30 @@
+parameters:
+  matchLabel: 'dummy-merge'
+  matchLabelPublic: 'dummy-merge'
+
+steps:
+  - script: mkdir $(System.DefaultWorkingDirectory)/patches && pip install requests urllib3
+    displayName: 'Prepare Environment'
+  - 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'
+  - task: PythonScript@0
+    displayName: 'Discover, Download, and Apply Patches (Mainline)'
+    inputs:
+      scriptSource: 'filePath'
+      scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
+      arguments: '${{ parameters.matchLabelPublic }} $(MergeTaglinePublic) patches-public'
+      workingDirectory: '$(System.DefaultWorkingDirectory)'
+  - task: PythonScript@0
+    displayName: 'Discover, Download, and Apply Patches (Patreon Public)'
+    inputs:
+      scriptSource: 'filePath'
+      scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
+      arguments: '${{ parameters.matchLabel }} "$(MergeTaglinePrivate) Public" patches-mixed-public'
+      workingDirectory: '$(System.DefaultWorkingDirectory)'
+  - task: PythonScript@0
+    displayName: 'Discover, Download, and Apply Patches (Patreon Private)'
+    inputs:
+      scriptSource: 'filePath'
+      scriptPath: '.ci/scripts/merge/apply-patches-by-label-private.py'
+      arguments: '$(PrivateMergeUser) ${{ parameters.matchLabel }} "$(MergeTaglinePrivate) Private" patches-private'
+      workingDirectory: '$(System.DefaultWorkingDirectory)'

.ci/templates/mergebot.yml

@@ -11,5 +11,5 @@ steps:
     inputs:
       scriptSource: 'filePath'
       scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
-      arguments: '${{ parameters.matchLabel }} patches'
+      arguments: '${{ parameters.matchLabel }} Tagged patches'
       workingDirectory: '$(System.DefaultWorkingDirectory)'

.ci/templates/release-download.yml

@@ -0,0 +1,13 @@
+steps:
+  - task: DownloadPipelineArtifact@2
+    displayName: 'Download Windows Release'
+    inputs:
+      artifactName: 'yuzu-$(BuildName)-windows-msvc'
+      buildType: 'current'
+      targetPath: '$(Build.ArtifactStagingDirectory)'
+  - task: DownloadPipelineArtifact@2
+    displayName: 'Download Linux Release'
+    inputs:
+      artifactName: 'yuzu-$(BuildName)-linux'
+      buildType: 'current'
+      targetPath: '$(Build.ArtifactStagingDirectory)'

.ci/templates/release-github.yml

@@ -0,0 +1,13 @@
+steps:
+  - template: ./release-download.yml
+  - task: GitHubRelease@0
+    displayName: 'GitHub Release'
+    inputs:
+      action: 'create'
+      title: '$(ReleasePrefix) $(DisplayVersion)'
+      assets: '$(Build.ArtifactStagingDirectory)/*'
+      gitHubConnection: $(GitHubReleaseConnectionName)
+      repositoryName: '$(Build.Repository.Name)'
+      target: '$(Build.SourceVersion)'
+      tagSource: manual
+      tag: $(BuildName)-$(DisplayPrefix)-$(DisplayVersion)

.ci/templates/release-private-tag.yml

@@ -0,0 +1,9 @@
+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'

.ci/templates/release-universal.yml

@@ -0,0 +1,10 @@
+steps:
+  - template: ./release-download.yml
+  - task: UniversalPackages@0
+    displayName: Publish Artifacts
+    inputs:
+      command: publish
+      publishDirectory: '$(Build.ArtifactStagingDirectory)'
+      vstsFeedPublish: 'yuzu-$(BuildName)'
+      vstsFeedPackagePublish: 'main'
+      packagePublishDescription: 'Yuzu Windows and Linux Executable Packages'

.ci/yuzu-mainline-step1.yml

@@ -0,0 +1,8 @@
+trigger:
+- master
+
+stages:
+- stage: merge
+  displayName: 'merge'
+  jobs:
+  - template: ./templates/merge.yml

.ci/yuzu-mainline-step2.yml

@@ -0,0 +1,68 @@
+trigger:
+- master
+
+variables:
+  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]
+
+stages:
+- stage: format
+  displayName: 'format'
+  jobs:
+  - job: format
+    displayName: 'clang'
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - template: ./templates/format-check.yml
+- stage: build
+  dependsOn: format
+  displayName: 'build'
+  jobs:
+  - job: build
+    displayName: 'standard'
+    pool:
+      vmImage: ubuntu-latest
+    strategy:
+      maxParallel: 10
+      matrix:
+        linux:
+          BuildSuffix: 'linux'
+          ScriptFolder: 'linux'
+    steps:
+    - template: ./templates/sync-source.yml
+      parameters:
+        artifactSource: $(parameters.artifactSource)
+        needSubmodules: 'true'
+    - template: ./templates/build-single.yml
+      parameters:
+        artifactSource: 'false'
+        cache: 'true'
+        version: $(DisplayVersion)
+- stage: build_win
+  dependsOn: format
+  displayName: 'build-windows'
+  jobs:
+  - job: build
+    displayName: 'msvc'
+    pool:
+      vmImage: vs2017-win2016
+    steps:
+    - template: ./templates/sync-source.yml
+      parameters:
+        artifactSource: $(parameters.artifactSource)
+        needSubmodules: 'true'
+    - template: ./templates/build-msvc.yml
+      parameters:
+        artifactSource: 'false'
+        cache: 'true'
+        version: $(DisplayVersion)
+- stage: release
+  displayName: 'release'
+  dependsOn:
+  - build
+  - build_win
+  jobs:
+  - job: github
+    displayName: 'github'
+    steps:
+    - template: ./templates/release-github.yml

.ci/yuzu-mainline.yml

@@ -1,25 +0,0 @@
-trigger:
-- master
-
-stages:
-- stage: merge
-  displayName: 'merge'
-  jobs:
-  - template: ./templates/merge.yml
-- stage: format
-  dependsOn: merge
-  displayName: 'format'
-  jobs:
-  - job: format
-    displayName: 'clang'
-    pool:
-      vmImage: ubuntu-latest
-    steps:
-    - template: ./templates/format-check.yml
-- stage: build
-  displayName: 'build'
-  dependsOn: format
-  jobs:
-  - template: ./templates/build-standard.yml
-    parameters:
-      cache: 'true'

.ci/yuzu-patreon-step1.yml

@@ -0,0 +1,8 @@
+trigger:
+- master
+
+stages:
+- stage: merge
+  displayName: 'merge'
+  jobs:
+  - template: ./templates/merge-private.yml

.ci/yuzu-patreon-step2.yml

@@ -0,0 +1,42 @@
+trigger:
+- master
+
+variables:
+  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]
+
+stages:
+- stage: format
+  displayName: 'format'
+  jobs:
+  - job: format
+    displayName: 'clang'
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - template: ./templates/format-check.yml
+- stage: build
+  dependsOn: format
+  displayName: 'build'
+  jobs:
+  - job: build
+    displayName: 'windows-msvc'
+    pool:
+      vmImage: vs2017-win2016
+    steps:
+    - template: ./templates/sync-source.yml
+      parameters:
+        artifactSource: $(parameters.artifactSource)
+        needSubmodules: 'true'
+    - template: ./templates/build-msvc.yml
+      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

.ci/yuzu-patreon.yml

@@ -1,19 +0,0 @@
-# Starter pipeline
-# Start with a minimal pipeline that you can customize to build and deploy your code.
-# Add steps that build, run tests, deploy, and more:
-# https://aka.ms/yaml
-
-trigger:
-- master
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-steps:
-- script: echo Hello, world!
-  displayName: 'Run a one-line script'
-
-- script: |
-    echo Add other tasks to build, test, and deploy your project.
-    echo See https://aka.ms/yaml
-  displayName: 'Run a multi-line script'

.gitmodules

@@ -46,3 +46,9 @@
 [submodule "sirit"]
     path = externals/sirit
     url = https://github.com/ReinUsesLisp/sirit
+[submodule "libzip"]
+    path = externals/libzip
+    url = https://github.com/DarkLordZach/libzip
+[submodule "zlib"]
+    path = externals/zlib
+    url = https://github.com/madler/zlib

CMakeLists.txt

@@ -21,6 +21,8 @@ option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
 
+option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
+
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
 option(ENABLE_VULKAN "Enables Vulkan backend" ON)

CMakeModules/GenerateSCMRev.cmake

@@ -83,9 +83,15 @@ 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"

CONTRIBUTING.md

@@ -1 +1 @@
-**The Contributor's Guide has moved to [the Citra wiki](https://github.com/citra-emu/citra/wiki/Contributing).**
+**The Contributor's Guide has moved to [the Yuzu wiki](https://github.com/yuzu-emu/yuzu/wiki/Contributing).**

README.md

@@ -1,14 +1,15 @@
 yuzu emulator
 =============
 [![Travis CI Build Status](https://travis-ci.org/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.org/yuzu-emu/yuzu)
-[![AppVeyor CI Build Status](https://ci.appveyor.com/api/projects/status/77k97svb2usreu68?svg=true)](https://ci.appveyor.com/project/bunnei/yuzu)
 [![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
 
 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).
 
-It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
+It is written in C++ with portability in mind, with builds actively maintained for Windows and Linux. The emulator is capable of running several commercial games.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. yuzu can boot some games, to varying degrees of success.
+yuzu only emulates a subset of Switch hardware and therefore most commercial games **do not** run at full speed or are not fully functional.
+
+Do you want to check which games are compatible and which ones are not? Please visit our [Compatibility page](https://yuzu-emu.org/game/)!
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

dist/yuzu.svg

@@ -1,86 +1 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   version="1.1"
-   id="svg815"
-   xml:space="preserve"
-   width="72"
-   height="80"
-   viewBox="0 0 72 80"
-   sodipodi:docname="center-logo-v3.svg"
-   inkscape:version="0.92.2 (5c3e80d, 2017-08-06)"><metadata
-     id="metadata821"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
-     id="defs819"><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath831"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path829"
-         inkscape:connector-curvature="0" /></clipPath><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath843"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path841"
-         inkscape:connector-curvature="0" /></clipPath><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath855"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path853"
-         inkscape:connector-curvature="0" /></clipPath><clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath867"><path
-         d="M 0,60 H 54 V 0 H 0 Z"
-         id="path865"
-         inkscape:connector-curvature="0" /></clipPath></defs><sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1920"
-     inkscape:window-height="1017"
-     id="namedview817"
-     showgrid="false"
-     inkscape:zoom="7.4953319"
-     inkscape:cx="28.177201"
-     inkscape:cy="44.348084"
-     inkscape:window-x="-8"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="g823" /><g
-     id="g823"
-     inkscape:groupmode="layer"
-     inkscape:label="center-logo-v3"
-     transform="matrix(1.3333333,0,0,-1.3333333,0,80)"><g
-       id="right"
-       inkscape:label="#g825"><g
-         id="g827"
-         clip-path="url(#clipPath831)"><g
-           id="g833"
-           transform="translate(30,48)"><path
-             d="m 0,0 v -48 c 13.255,0 24,10.745 24,24 C 24,-10.745 13.255,0 0,0 M 3,-3.214 C 13.163,-4.674 21,-13.439 21,-24 21,-34.561 13.163,-43.326 3,-44.786 v 41.572"
-             style="fill:#ff3c28;fill-opacity:1;fill-rule:nonzero;stroke:none"
-             id="path835"
-             inkscape:connector-curvature="0" /></g></g></g><g
-       id="left"
-       inkscape:label="#g837"><g
-         id="g839"
-         clip-path="url(#clipPath843)"><g
-           id="g845"
-           transform="translate(24,60)"><path
-             d="m 0,0 c -13.255,0 -24,-10.745 -24,-24 0,-13.255 10.745,-24 24,-24 z m -3,-3.214 v -41.572 c -10.163,1.46 -18,10.225 -18,20.786 0,10.561 7.837,19.326 18,20.786"
-             style="fill:#0ab9e6;fill-opacity:1;fill-rule:nonzero;stroke:none"
-             id="path847"
-             inkscape:connector-curvature="0" /></g></g></g></g></svg>
+<svg id="svg815" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 614.4 682.67"><defs><style>.cls-1{fill:none;}.cls-2{clip-path:url(#clip-path);}.cls-3{fill:#ff3c28;}.cls-4{fill:#0ab9e6;}</style><clipPath id="clip-path"><rect class="cls-1" x="-43" y="-46.67" width="699.6" height="777.33"/></clipPath></defs><title>Artboard 1</title><g id="g823"><g id="right"><g class="cls-2"><g id="g827"><g id="g833"><path id="path835" class="cls-3" d="M340.81,138V682.08c150.26,0,272.06-121.81,272.06-272.06S491.07,138,340.81,138M394,197.55a219.06,219.06,0,0,1,0,424.94V197.55"/></g></g></g></g><g id="left"><g class="cls-2"><g id="g839"><g id="g845"><path id="path847" class="cls-4" d="M272.79,1.92C122.53,1.92.73,123.73.73,274s121.8,272.07,272.06,272.07ZM219.65,61.51v425A219,219,0,0,1,118,119.18,217.51,217.51,0,0,1,219.65,61.51"/></g></g></g></g></g></svg>

externals/CMakeLists.txt

@@ -77,6 +77,12 @@ if (ENABLE_VULKAN)
     add_subdirectory(sirit)
 endif()
 
+# zlib
+add_subdirectory(zlib EXCLUDE_FROM_ALL)
+
+# libzip
+add_subdirectory(libzip EXCLUDE_FROM_ALL)
+
 if (ENABLE_WEB_SERVICE)
     # LibreSSL
     set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")

license.txt

@@ -341,15 +341,24 @@ 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                    | 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
+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.

src/audio_core/audio_renderer.cpp

@@ -107,6 +107,11 @@ Stream::State AudioRenderer::GetStreamState() const {
     return stream->GetState();
 }
 
+static constexpr u32 VersionFromRevision(u32_le rev) {
+    // "REV7" -> 7
+    return ((rev >> 24) & 0xff) - 0x30;
+}
+
 std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
     // Copy UpdateDataHeader struct
     UpdateDataHeader config{};
@@ -166,6 +171,11 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
     // Copy output header
     UpdateDataHeader response_data{worker_params};
     std::vector<u8> output_params(response_data.total_size);
+    const auto audren_revision = VersionFromRevision(config.revision);
+    if (audren_revision >= 5) {
+        response_data.frame_count = 0x10;
+        response_data.total_size += 0x10;
+    }
     std::memcpy(output_params.data(), &response_data, sizeof(UpdateDataHeader));
 
     // Copy output memory pool entries

src/audio_core/audio_renderer.h

@@ -194,21 +194,24 @@ struct UpdateDataHeader {
         mixes_size = 0x0;
         sinks_size = config.sink_count * 0x20;
         performance_manager_size = 0x10;
+        frame_count = 0;
         total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size + voices_size +
                      effects_size + sinks_size + performance_manager_size;
     }
 
-    u32_le revision;
-    u32_le behavior_size;
-    u32_le memory_pools_size;
-    u32_le voices_size;
-    u32_le voice_resource_size;
-    u32_le effects_size;
-    u32_le mixes_size;
-    u32_le sinks_size;
-    u32_le performance_manager_size;
-    INSERT_PADDING_WORDS(6);
-    u32_le total_size;
+    u32_le revision{};
+    u32_le behavior_size{};
+    u32_le memory_pools_size{};
+    u32_le voices_size{};
+    u32_le voice_resource_size{};
+    u32_le effects_size{};
+    u32_le mixes_size{};
+    u32_le sinks_size{};
+    u32_le performance_manager_size{};
+    INSERT_PADDING_WORDS(1);
+    u32_le frame_count{};
+    INSERT_PADDING_WORDS(4);
+    u32_le total_size{};
 };
 static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size");
 

src/common/CMakeLists.txt

@@ -10,13 +10,28 @@ if (DEFINED ENV{CI})
   elseif(DEFINED ENV{APPVEYOR})
     set(BUILD_REPOSITORY $ENV{APPVEYOR_REPO_NAME})
     set(BUILD_TAG $ENV{APPVEYOR_REPO_TAG_NAME})
+  elseif(DEFINED ENV{AZURE})
+    set(BUILD_REPOSITORY $ENV{AZURE_REPO_NAME})
+    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,
@@ -57,9 +72,15 @@ 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"

src/common/alignment.h

@@ -51,7 +51,17 @@ 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);
     }

src/common/assert.h

@@ -28,18 +28,14 @@ __declspec(noinline, noreturn)
 }
 
 #define ASSERT(_a_)                                                                                \
-    do                                                                                             \
-        if (!(_a_)) {                                                                              \
-            assert_noinline_call([] { LOG_CRITICAL(Debug, "Assertion Failed!"); });                \
-        }                                                                                          \
-    while (0)
+    if (!(_a_)) {                                                                                  \
+        LOG_CRITICAL(Debug, "Assertion Failed!");                                                  \
+    }
 
 #define ASSERT_MSG(_a_, ...)                                                                       \
-    do                                                                                             \
-        if (!(_a_)) {                                                                              \
-            assert_noinline_call([&] { LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); }); \
-        }                                                                                          \
-    while (0)
+    if (!(_a_)) {                                                                                  \
+        LOG_CRITICAL(Debug, "Assertion Failed! " __VA_ARGS__);                                     \
+    }
 
 #define UNREACHABLE() ASSERT_MSG(false, "Unreachable code!")
 #define UNREACHABLE_MSG(...) ASSERT_MSG(false, __VA_ARGS__)

src/common/file_util.cpp

@@ -713,7 +713,6 @@ 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,6 +720,8 @@ 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;
         }
     }
 

src/common/logging/backend.cpp

@@ -255,6 +255,7 @@ void DebuggerBackend::Write(const Entry& entry) {
     CLS(Input)                                                                                     \
     CLS(Network)                                                                                   \
     CLS(Loader)                                                                                    \
+    CLS(CheatEngine)                                                                               \
     CLS(Crypto)                                                                                    \
     CLS(WebService)
 

src/common/logging/log.h

@@ -117,6 +117,7 @@ enum class Class : ClassType {
     Audio_DSP,         ///< The HLE implementation of the DSP
     Audio_Sink,        ///< Emulator audio output backend
     Loader,            ///< ROM loader
+    CheatEngine,       ///< Memory manipulation and engine VM functions
     Crypto,            ///< Cryptographic engine/functions
     Input,             ///< Input emulation
     Network,           ///< Network emulation

src/common/scm_rev.cpp.in

@@ -11,6 +11,9 @@
 #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 {
@@ -22,6 +25,9 @@ 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

src/common/scm_rev.h

@@ -13,6 +13,9 @@ 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

src/core/CMakeLists.txt

@@ -1,3 +1,9 @@
+if (YUZU_ENABLE_BOXCAT)
+    set(BCAT_BOXCAT_ADDITIONAL_SOURCES hle/service/bcat/backend/boxcat.cpp hle/service/bcat/backend/boxcat.h)
+else()
+    set(BCAT_BOXCAT_ADDITIONAL_SOURCES)
+endif()
+
 add_library(core STATIC
     arm/arm_interface.h
     arm/arm_interface.cpp
@@ -33,8 +39,6 @@ add_library(core STATIC
     file_sys/bis_factory.h
     file_sys/card_image.cpp
     file_sys/card_image.h
-    file_sys/cheat_engine.cpp
-    file_sys/cheat_engine.h
     file_sys/content_archive.cpp
     file_sys/content_archive.h
     file_sys/control_metadata.cpp
@@ -70,6 +74,8 @@ add_library(core STATIC
     file_sys/sdmc_factory.h
     file_sys/submission_package.cpp
     file_sys/submission_package.h
+    file_sys/system_archive/mii_model.cpp
+    file_sys/system_archive/mii_model.h
     file_sys/system_archive/ng_word.cpp
     file_sys/system_archive/ng_word.h
     file_sys/system_archive/system_archive.cpp
@@ -82,6 +88,8 @@ add_library(core STATIC
     file_sys/vfs_concat.h
     file_sys/vfs_layered.cpp
     file_sys/vfs_layered.h
+    file_sys/vfs_libzip.cpp
+    file_sys/vfs_libzip.h
     file_sys/vfs_offset.cpp
     file_sys/vfs_offset.h
     file_sys/vfs_real.cpp
@@ -241,6 +249,9 @@ add_library(core STATIC
     hle/service/audio/errors.h
     hle/service/audio/hwopus.cpp
     hle/service/audio/hwopus.h
+    hle/service/bcat/backend/backend.cpp
+    hle/service/bcat/backend/backend.h
+    ${BCAT_BOXCAT_ADDITIONAL_SOURCES}
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
     hle/service/bcat/module.cpp
@@ -324,6 +335,8 @@ 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
@@ -475,6 +488,11 @@ add_library(core STATIC
     loader/nsp.h
     loader/xci.cpp
     loader/xci.h
+    memory/cheat_engine.cpp
+    memory/cheat_engine.h
+    memory/dmnt_cheat_types.h
+    memory/dmnt_cheat_vm.cpp
+    memory/dmnt_cheat_vm.h
     memory.cpp
     memory.h
     memory_setup.h
@@ -494,6 +512,15 @@ create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
 target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn open_source_archives)
+
+if (YUZU_ENABLE_BOXCAT)
+    get_directory_property(OPENSSL_LIBS
+        DIRECTORY ${PROJECT_SOURCE_DIR}/externals/libressl
+        DEFINITION OPENSSL_LIBS)
+    target_compile_definitions(core PRIVATE -DCPPHTTPLIB_OPENSSL_SUPPORT -DYUZU_ENABLE_BOXCAT)
+    target_link_libraries(core PRIVATE httplib json-headers ${OPENSSL_LIBS} zip)
+endif()
+
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
     target_link_libraries(core PRIVATE web_service)

src/core/core.cpp

@@ -14,8 +14,14 @@
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/cpu_core_manager.h"
+#include "core/file_sys/bis_factory.h"
+#include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
+#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
+#include "core/file_sys/romfs_factory.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
@@ -27,17 +33,18 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/am/applets/applets.h"
 #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"
+#include "core/memory/cheat_engine.h"
 #include "core/perf_stats.h"
 #include "core/reporter.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "core/tools/freezer.h"
-#include "file_sys/cheat_engine.h"
-#include "file_sys/patch_manager.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
@@ -104,7 +111,9 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 struct System::Impl {
-    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system}, reporter{system} {}
+    explicit Impl(System& system)
+        : kernel{system}, fs_controller{system}, cpu_core_manager{system},
+          applet_manager{system}, reporter{system} {}
 
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
@@ -156,13 +165,10 @@ struct System::Impl {
         gpu_core = VideoCore::CreateGPU(system);
 
         is_powered_on = true;
+        exit_lock = false;
 
         LOG_DEBUG(Core, "Initialized OK");
 
-        // Reset counters and set time origin to current frame
-        GetAndResetPerfStats();
-        perf_stats.BeginSystemFrame();
-
         return ResultStatus::Success;
     }
 
@@ -201,10 +207,34 @@ struct System::Impl {
         gpu_core->Start();
         cpu_core_manager.StartThreads();
 
+        // Initialize cheat engine
+        if (cheat_engine) {
+            cheat_engine->Initialize();
+        }
+
         // All threads are started, begin main process execution, now that we're in the clear.
         main_process->Run(load_parameters->main_thread_priority,
                           load_parameters->main_thread_stack_size);
 
+        if (Settings::values.gamecard_inserted) {
+            if (Settings::values.gamecard_current_game) {
+                fs_controller.SetGameCard(GetGameFileFromPath(virtual_filesystem, filepath));
+            } else if (!Settings::values.gamecard_path.empty()) {
+                fs_controller.SetGameCard(
+                    GetGameFileFromPath(virtual_filesystem, Settings::values.gamecard_path));
+            }
+        }
+
+        u64 title_id{0};
+        if (app_loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
+            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})",
+                      static_cast<u32>(load_result));
+        }
+        perf_stats = std::make_unique<PerfStats>(title_id);
+        // Reset counters and set time origin to current frame
+        GetAndResetPerfStats();
+        perf_stats->BeginSystemFrame();
+
         status = ResultStatus::Success;
         return status;
     }
@@ -218,8 +248,15 @@ struct System::Impl {
                                     perf_results.game_fps);
         telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
                                     perf_results.frametime * 1000.0);
+        telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS",
+                                    perf_stats->GetMeanFrametime());
+
+        lm_manager.Flush();
 
         is_powered_on = false;
+        exit_lock = false;
+
+        gpu_core->WaitIdle();
 
         // Shutdown emulation session
         renderer.reset();
@@ -228,6 +265,7 @@ struct System::Impl {
         service_manager.reset();
         cheat_engine.reset();
         telemetry_session.reset();
+        perf_stats.reset();
         gpu_core.reset();
 
         // Close all CPU/threading state
@@ -285,7 +323,7 @@ struct System::Impl {
     }
 
     PerfStatsResults GetAndResetPerfStats() {
-        return perf_stats.GetAndResetStats(core_timing.GetGlobalTimeUs());
+        return perf_stats->GetAndResetStats(core_timing.GetGlobalTimeUs());
     }
 
     Timing::CoreTiming core_timing;
@@ -294,6 +332,7 @@ struct System::Impl {
     FileSys::VirtualFilesystem virtual_filesystem;
     /// ContentProviderUnion instance
     std::unique_ptr<FileSys::ContentProviderUnion> content_provider;
+    Service::FileSystem::FileSystemController fs_controller;
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
     std::unique_ptr<VideoCore::RendererBase> renderer;
@@ -302,9 +341,12 @@ struct System::Impl {
     std::unique_ptr<Core::Hardware::InterruptManager> interrupt_manager;
     CpuCoreManager cpu_core_manager;
     bool is_powered_on = false;
+    bool exit_lock = false;
 
-    std::unique_ptr<FileSys::CheatEngine> cheat_engine;
+    Reporter reporter;
+    std::unique_ptr<Memory::CheatEngine> cheat_engine;
     std::unique_ptr<Tools::Freezer> memory_freezer;
+    std::array<u8, 0x20> build_id{};
 
     /// Frontend applets
     Service::AM::Applets::AppletManager applet_manager;
@@ -312,8 +354,9 @@ struct System::Impl {
     /// APM (Performance) services
     Service::APM::Controller apm_controller{core_timing};
 
-    /// Glue services
+    /// Service State
     Service::Glue::ARPManager arp_manager;
+    Service::LM::Manager lm_manager{reporter};
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -321,12 +364,10 @@ 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 = "";
 
-    Core::PerfStats perf_stats;
+    std::unique_ptr<Core::PerfStats> perf_stats;
     Core::FrameLimiter frame_limiter;
 };
 
@@ -365,6 +406,12 @@ 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();
 }
@@ -405,6 +452,16 @@ 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();
 }
@@ -479,11 +536,11 @@ const Timing::CoreTiming& System::CoreTiming() const {
 }
 
 Core::PerfStats& System::GetPerfStats() {
-    return impl->perf_stats;
+    return *impl->perf_stats;
 }
 
 const Core::PerfStats& System::GetPerfStats() const {
-    return impl->perf_stats;
+    return *impl->perf_stats;
 }
 
 Core::FrameLimiter& System::FrameLimiter() {
@@ -518,13 +575,6 @@ Tegra::DebugContext* System::GetGPUDebugContext() const {
     return impl->debug_context.get();
 }
 
-void System::RegisterCheatList(const std::vector<FileSys::CheatList>& list,
-                               const std::string& build_id, VAddr code_region_start,
-                               VAddr code_region_end) {
-    impl->cheat_engine = std::make_unique<FileSys::CheatEngine>(*this, list, build_id,
-                                                                code_region_start, code_region_end);
-}
-
 void System::SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs) {
     impl->virtual_filesystem = std::move(vfs);
 }
@@ -533,6 +583,13 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
+void System::RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
+                               const std::array<u8, 32>& build_id, VAddr main_region_begin,
+                               u64 main_region_size) {
+    impl->cheat_engine = std::make_unique<Memory::CheatEngine>(*this, list, build_id);
+    impl->cheat_engine->SetMainMemoryParameters(main_region_begin, main_region_size);
+}
+
 void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
     impl->applet_manager.SetAppletFrontendSet(std::move(set));
 }
@@ -561,6 +618,14 @@ const FileSys::ContentProvider& System::GetContentProvider() const {
     return *impl->content_provider;
 }
 
+Service::FileSystem::FileSystemController& System::GetFileSystemController() {
+    return impl->fs_controller;
+}
+
+const Service::FileSystem::FileSystemController& System::GetFileSystemController() const {
+    return impl->fs_controller;
+}
+
 void System::RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
                                      FileSys::ContentProvider* provider) {
     impl->content_provider->SetSlot(slot, provider);
@@ -590,6 +655,30 @@ 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;
+}
+
+bool System::GetExitLock() const {
+    return impl->exit_lock;
+}
+
+void System::SetCurrentProcessBuildID(const CurrentBuildProcessID& id) {
+    impl->build_id = id;
+}
+
+const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
+    return impl->build_id;
+}
+
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -8,7 +8,6 @@
 #include <memory>
 #include <string>
 
-#include <map>
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
@@ -18,7 +17,6 @@ class EmuWindow;
 } // namespace Core::Frontend
 
 namespace FileSys {
-class CheatList;
 class ContentProvider;
 class ContentProviderUnion;
 enum class ContentProviderUnionSlot;
@@ -26,6 +24,7 @@ class VfsFilesystem;
 } // namespace FileSys
 
 namespace Kernel {
+class GlobalScheduler;
 class KernelCore;
 class Process;
 class Scheduler;
@@ -36,6 +35,10 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader
 
+namespace Memory {
+struct CheatEntry;
+} // namespace Memory
+
 namespace Service {
 
 namespace AM::Applets {
@@ -47,10 +50,18 @@ namespace APM {
 class Controller;
 }
 
+namespace FileSystem {
+class FileSystemController;
+} // namespace FileSystem
+
 namespace Glue {
 class ARPManager;
 }
 
+namespace LM {
+class Manager;
+} // namespace LM
+
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -91,6 +102,8 @@ 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;
 
@@ -172,6 +185,9 @@ 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();
 
@@ -226,6 +242,12 @@ 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();
 
@@ -282,8 +304,9 @@ public:
 
     std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
 
-    void RegisterCheatList(const std::vector<FileSys::CheatList>& list, const std::string& build_id,
-                           VAddr code_region_start, VAddr code_region_end);
+    void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
+                           const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
+                           u64 main_region_size);
 
     void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
 
@@ -299,6 +322,10 @@ public:
 
     const FileSys::ContentProvider& GetContentProvider() const;
 
+    Service::FileSystem::FileSystemController& GetFileSystemController();
+
+    const Service::FileSystem::FileSystemController& GetFileSystemController() const;
+
     void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
                                  FileSys::ContentProvider* provider);
 
@@ -314,6 +341,18 @@ 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);
+
+    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
+
 private:
     System();
 
@@ -337,8 +376,4 @@ private:
     static System s_instance;
 };
 
-inline Kernel::Process* CurrentProcess() {
-    return System::GetInstance().CurrentProcess();
-}
-
 } // namespace Core

src/core/core_cpu.cpp

@@ -52,7 +52,8 @@ bool CpuBarrier::Rendezvous() {
 
 Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
          std::size_t core_index)
-    : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
+    : cpu_barrier{cpu_barrier}, global_scheduler{system.GlobalScheduler()},
+      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
@@ -60,7 +61,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);
+    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
 }
 
 Cpu::~Cpu() = default;
@@ -81,6 +82,8 @@ 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) {
@@ -92,7 +95,6 @@ void Cpu::RunLoop(bool tight_loop) {
             core_timing.Advance();
         }
 
-        PrepareReschedule();
     } else {
         if (IsMainCore()) {
             core_timing.Advance();
@@ -114,18 +116,14 @@ void Cpu::SingleStep() {
 
 void Cpu::PrepareReschedule() {
     arm_interface->PrepareReschedule();
-    reschedule_pending = true;
 }
 
 void Cpu::Reschedule() {
-    if (!reschedule_pending) {
-        return;
-    }
-
-    reschedule_pending = false;
     // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard lock{HLE::g_hle_lock};
-    scheduler->Reschedule();
+    std::lock_guard lock(HLE::g_hle_lock);
+
+    global_scheduler.SelectThread(core_index);
+    scheduler->TryDoContextSwitch();
 }
 
 } // namespace Core

src/core/core_cpu.h

@@ -12,8 +12,9 @@
 #include "common/common_types.h"
 
 namespace Kernel {
+class GlobalScheduler;
 class Scheduler;
-}
+} // namespace Kernel
 
 namespace Core {
 class System;
@@ -90,6 +91,7 @@ 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;
 

src/core/crypto/key_manager.cpp

@@ -37,6 +37,7 @@
 namespace Core::Crypto {
 
 constexpr u64 CURRENT_CRYPTO_REVISION = 0x5;
+constexpr u64 FULL_TICKET_SIZE = 0x400;
 
 using namespace Common;
 
@@ -55,6 +56,99 @@ const std::map<std::pair<S128KeyType, u64>, std::string> KEYS_VARIABLE_LENGTH{
     {{S128KeyType::KeyblobMAC, 0}, "keyblob_mac_key_"},
 };
 
+namespace {
+template <std::size_t Size>
+bool IsAllZeroArray(const std::array<u8, Size>& array) {
+    return std::all_of(array.begin(), array.end(), [](const auto& elem) { return elem == 0; });
+}
+} // namespace
+
+u64 GetSignatureTypeDataSize(SignatureType type) {
+    switch (type) {
+    case SignatureType::RSA_4096_SHA1:
+    case SignatureType::RSA_4096_SHA256:
+        return 0x200;
+    case SignatureType::RSA_2048_SHA1:
+    case SignatureType::RSA_2048_SHA256:
+        return 0x100;
+    case SignatureType::ECDSA_SHA1:
+    case SignatureType::ECDSA_SHA256:
+        return 0x3C;
+    }
+    UNREACHABLE();
+}
+
+u64 GetSignatureTypePaddingSize(SignatureType type) {
+    switch (type) {
+    case SignatureType::RSA_4096_SHA1:
+    case SignatureType::RSA_4096_SHA256:
+    case SignatureType::RSA_2048_SHA1:
+    case SignatureType::RSA_2048_SHA256:
+        return 0x3C;
+    case SignatureType::ECDSA_SHA1:
+    case SignatureType::ECDSA_SHA256:
+        return 0x40;
+    }
+    UNREACHABLE();
+}
+
+SignatureType Ticket::GetSignatureType() const {
+    if (auto ticket = std::get_if<RSA4096Ticket>(&data)) {
+        return ticket->sig_type;
+    }
+    if (auto ticket = std::get_if<RSA2048Ticket>(&data)) {
+        return ticket->sig_type;
+    }
+    if (auto ticket = std::get_if<ECDSATicket>(&data)) {
+        return ticket->sig_type;
+    }
+
+    UNREACHABLE();
+}
+
+TicketData& Ticket::GetData() {
+    if (auto ticket = std::get_if<RSA4096Ticket>(&data)) {
+        return ticket->data;
+    }
+    if (auto ticket = std::get_if<RSA2048Ticket>(&data)) {
+        return ticket->data;
+    }
+    if (auto ticket = std::get_if<ECDSATicket>(&data)) {
+        return ticket->data;
+    }
+
+    UNREACHABLE();
+}
+
+const TicketData& Ticket::GetData() const {
+    if (auto ticket = std::get_if<RSA4096Ticket>(&data)) {
+        return ticket->data;
+    }
+    if (auto ticket = std::get_if<RSA2048Ticket>(&data)) {
+        return ticket->data;
+    }
+    if (auto ticket = std::get_if<ECDSATicket>(&data)) {
+        return ticket->data;
+    }
+
+    UNREACHABLE();
+}
+
+u64 Ticket::GetSize() const {
+    const auto sig_type = GetSignatureType();
+
+    return sizeof(SignatureType) + GetSignatureTypeDataSize(sig_type) +
+           GetSignatureTypePaddingSize(sig_type) + sizeof(TicketData);
+}
+
+Ticket Ticket::SynthesizeCommon(Key128 title_key, const std::array<u8, 16>& rights_id) {
+    RSA2048Ticket out{};
+    out.sig_type = SignatureType::RSA_2048_SHA256;
+    out.data.rights_id = rights_id;
+    out.data.title_key_common = title_key;
+    return Ticket{out};
+}
+
 Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed) {
     Key128 out{};
 
@@ -135,6 +229,27 @@ void KeyManager::DeriveGeneralPurposeKeys(std::size_t crypto_revision) {
     }
 }
 
+RSAKeyPair<2048> KeyManager::GetETicketRSAKey() const {
+    if (IsAllZeroArray(eticket_extended_kek) || !HasKey(S128KeyType::ETicketRSAKek))
+        return {};
+
+    const auto eticket_final = GetKey(S128KeyType::ETicketRSAKek);
+
+    std::vector<u8> extended_iv(eticket_extended_kek.begin(), eticket_extended_kek.begin() + 0x10);
+    std::array<u8, 0x230> extended_dec{};
+    AESCipher<Key128> rsa_1(eticket_final, Mode::CTR);
+    rsa_1.SetIV(extended_iv);
+    rsa_1.Transcode(eticket_extended_kek.data() + 0x10, eticket_extended_kek.size() - 0x10,
+                    extended_dec.data(), Op::Decrypt);
+
+    RSAKeyPair<2048> rsa_key{};
+    std::memcpy(rsa_key.decryption_key.data(), extended_dec.data(), rsa_key.decryption_key.size());
+    std::memcpy(rsa_key.modulus.data(), extended_dec.data() + 0x100, rsa_key.modulus.size());
+    std::memcpy(rsa_key.exponent.data(), extended_dec.data() + 0x200, rsa_key.exponent.size());
+
+    return rsa_key;
+}
+
 Key128 DeriveKeyblobMACKey(const Key128& keyblob_key, const Key128& mac_source) {
     AESCipher<Key128> mac_cipher(keyblob_key, Mode::ECB);
     Key128 mac_key{};
@@ -237,7 +352,7 @@ Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& ke
     return Loader::ResultStatus::Success;
 }
 
-std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save) {
+std::vector<Ticket> GetTicketblob(const FileUtil::IOFile& ticket_save) {
     if (!ticket_save.IsOpen())
         return {};
 
@@ -246,14 +361,14 @@ std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save) {
         return {};
     }
 
-    std::vector<TicketRaw> out;
+    std::vector<Ticket> out;
     for (std::size_t offset = 0; offset + 0x4 < buffer.size(); ++offset) {
         if (buffer[offset] == 0x4 && buffer[offset + 1] == 0x0 && buffer[offset + 2] == 0x1 &&
             buffer[offset + 3] == 0x0) {
             out.emplace_back();
             auto& next = out.back();
-            std::memcpy(&next, buffer.data() + offset, sizeof(TicketRaw));
-            offset += next.size();
+            std::memcpy(&next, buffer.data() + offset, sizeof(Ticket));
+            offset += FULL_TICKET_SIZE;
         }
     }
 
@@ -305,29 +420,23 @@ static std::optional<u64> FindTicketOffset(const std::array<u8, size>& data) {
     return offset;
 }
 
-std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
+std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
                                                      const RSAKeyPair<2048>& key) {
-    u32 cert_authority;
-    std::memcpy(&cert_authority, ticket.data() + 0x140, sizeof(cert_authority));
-    if (cert_authority == 0)
+    const auto issuer = ticket.GetData().issuer;
+    if (IsAllZeroArray(issuer))
         return {};
-    if (cert_authority != Common::MakeMagic('R', 'o', 'o', 't')) {
-        LOG_INFO(Crypto,
-                 "Attempting to parse ticket with non-standard certificate authority {:08X}.",
-                 cert_authority);
+    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.");
     }
 
-    Key128 rights_id;
-    std::memcpy(rights_id.data(), ticket.data() + 0x2A0, sizeof(Key128));
+    Key128 rights_id = ticket.GetData().rights_id;
 
     if (rights_id == Key128{})
         return {};
 
-    Key128 key_temp{};
-
-    if (!std::any_of(ticket.begin() + 0x190, ticket.begin() + 0x280, [](u8 b) { return b != 0; })) {
-        std::memcpy(key_temp.data(), ticket.data() + 0x180, key_temp.size());
-        return std::make_pair(rights_id, key_temp);
+    if (!std::any_of(ticket.GetData().title_key_common_pad.begin(),
+                     ticket.GetData().title_key_common_pad.end(), [](u8 b) { return b != 0; })) {
+        return std::make_pair(rights_id, ticket.GetData().title_key_common);
     }
 
     mbedtls_mpi D; // RSA Private Exponent
@@ -342,7 +451,7 @@ std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
 
     mbedtls_mpi_read_binary(&D, key.decryption_key.data(), key.decryption_key.size());
     mbedtls_mpi_read_binary(&N, key.modulus.data(), key.modulus.size());
-    mbedtls_mpi_read_binary(&S, ticket.data() + 0x180, 0x100);
+    mbedtls_mpi_read_binary(&S, ticket.GetData().title_key_block.data(), 0x100);
 
     mbedtls_mpi_exp_mod(&M, &S, &D, &N, nullptr);
 
@@ -366,6 +475,7 @@ std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
         return {};
     ASSERT(*offset > 0);
 
+    Key128 key_temp{};
     std::memcpy(key_temp.data(), m_2.data() + *offset, key_temp.size());
 
     return std::make_pair(rights_id, key_temp);
@@ -450,6 +560,8 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
 
                 const auto index = std::stoul(out[0].substr(18, 2), nullptr, 16);
                 encrypted_keyblobs[index] = Common::HexStringToArray<0xB0>(out[1]);
+            } else if (out[0].compare(0, 20, "eticket_extended_kek") == 0) {
+                eticket_extended_kek = Common::HexStringToArray<576>(out[1]);
             } else {
                 for (const auto& kv : KEYS_VARIABLE_LENGTH) {
                     if (!ValidCryptoRevisionString(out[0], kv.second.size(), 2))
@@ -862,20 +974,19 @@ void KeyManager::DeriveETicket(PartitionDataManager& data) {
     // Titlekeys
     data.DecryptProdInfo(GetBISKey(0));
 
-    const auto eticket_extended_kek = data.GetETicketExtendedKek();
+    eticket_extended_kek = data.GetETicketExtendedKek();
+    WriteKeyToFile(KeyCategory::Console, "eticket_extended_kek", eticket_extended_kek);
+    PopulateTickets();
+}
 
-    std::vector<u8> extended_iv(0x10);
-    std::memcpy(extended_iv.data(), eticket_extended_kek.data(), extended_iv.size());
-    std::array<u8, 0x230> extended_dec{};
-    AESCipher<Key128> rsa_1(eticket_final, Mode::CTR);
-    rsa_1.SetIV(extended_iv);
-    rsa_1.Transcode(eticket_extended_kek.data() + 0x10, eticket_extended_kek.size() - 0x10,
-                    extended_dec.data(), Op::Decrypt);
+void KeyManager::PopulateTickets() {
+    const auto rsa_key = GetETicketRSAKey();
 
-    RSAKeyPair<2048> rsa_key{};
-    std::memcpy(rsa_key.decryption_key.data(), extended_dec.data(), rsa_key.decryption_key.size());
-    std::memcpy(rsa_key.modulus.data(), extended_dec.data() + 0x100, rsa_key.modulus.size());
-    std::memcpy(rsa_key.exponent.data(), extended_dec.data() + 0x200, rsa_key.exponent.size());
+    if (rsa_key == RSAKeyPair<2048>{})
+        return;
+
+    if (!common_tickets.empty() && !personal_tickets.empty())
+        return;
 
     const FileUtil::IOFile save1(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                                      "/system/save/80000000000000e1",
@@ -886,19 +997,41 @@ void KeyManager::DeriveETicket(PartitionDataManager& data) {
 
     const auto blob2 = GetTicketblob(save2);
     auto res = GetTicketblob(save1);
+    const auto idx = res.size();
     res.insert(res.end(), blob2.begin(), blob2.end());
 
-    for (const auto& raw : res) {
-        const auto pair = ParseTicket(raw, rsa_key);
+    for (std::size_t i = 0; i < res.size(); ++i) {
+        const auto common = i < idx;
+        const auto pair = ParseTicket(res[i], rsa_key);
         if (!pair)
             continue;
         const auto& [rid, key] = *pair;
         u128 rights_id;
         std::memcpy(rights_id.data(), rid.data(), rid.size());
+
+        if (common) {
+            common_tickets[rights_id] = res[i];
+        } else {
+            personal_tickets[rights_id] = res[i];
+        }
+
         SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
     }
 }
 
+void KeyManager::SynthesizeTickets() {
+    for (const auto& key : s128_keys) {
+        if (key.first.type != S128KeyType::Titlekey) {
+            continue;
+        }
+        u128 rights_id{key.first.field1, key.first.field2};
+        Key128 rights_id_2;
+        std::memcpy(rights_id_2.data(), rights_id.data(), rights_id_2.size());
+        const auto ticket = Ticket::SynthesizeCommon(key.second, rights_id_2);
+        common_tickets.insert_or_assign(rights_id, ticket);
+    }
+}
+
 void KeyManager::SetKeyWrapped(S128KeyType id, Key128 key, u64 field1, u64 field2) {
     if (key == Key128{})
         return;
@@ -997,6 +1130,46 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) {
     DeriveBase();
 }
 
+const std::map<u128, Ticket>& KeyManager::GetCommonTickets() const {
+    return common_tickets;
+}
+
+const std::map<u128, Ticket>& KeyManager::GetPersonalizedTickets() const {
+    return personal_tickets;
+}
+
+bool KeyManager::AddTicketCommon(Ticket raw) {
+    const auto rsa_key = GetETicketRSAKey();
+    if (rsa_key == RSAKeyPair<2048>{})
+        return false;
+
+    const auto pair = ParseTicket(raw, rsa_key);
+    if (!pair)
+        return false;
+    const auto& [rid, key] = *pair;
+    u128 rights_id;
+    std::memcpy(rights_id.data(), rid.data(), rid.size());
+    common_tickets[rights_id] = raw;
+    SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
+    return true;
+}
+
+bool KeyManager::AddTicketPersonalized(Ticket raw) {
+    const auto rsa_key = GetETicketRSAKey();
+    if (rsa_key == RSAKeyPair<2048>{})
+        return false;
+
+    const auto pair = ParseTicket(raw, rsa_key);
+    if (!pair)
+        return false;
+    const auto& [rid, key] = *pair;
+    u128 rights_id;
+    std::memcpy(rights_id.data(), rid.data(), rid.size());
+    common_tickets[rights_id] = raw;
+    SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
+    return true;
+}
+
 const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager::s128_file_id = {
     {"eticket_rsa_kek", {S128KeyType::ETicketRSAKek, 0, 0}},
     {"eticket_rsa_kek_source",

src/core/crypto/key_manager.h

@@ -9,8 +9,10 @@
 #include <optional>
 #include <string>
 
+#include <variant>
 #include <boost/container/flat_map.hpp>
 #include <fmt/format.h>
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/crypto/partition_data_manager.h"
 #include "core/file_sys/vfs_types.h"
@@ -30,7 +32,79 @@ constexpr u64 TICKET_FILE_TITLEKEY_OFFSET = 0x180;
 using Key128 = std::array<u8, 0x10>;
 using Key256 = std::array<u8, 0x20>;
 using SHA256Hash = std::array<u8, 0x20>;
-using TicketRaw = std::array<u8, 0x400>;
+
+enum class SignatureType {
+    RSA_4096_SHA1 = 0x10000,
+    RSA_2048_SHA1 = 0x10001,
+    ECDSA_SHA1 = 0x10002,
+    RSA_4096_SHA256 = 0x10003,
+    RSA_2048_SHA256 = 0x10004,
+    ECDSA_SHA256 = 0x10005,
+};
+
+u64 GetSignatureTypeDataSize(SignatureType type);
+u64 GetSignatureTypePaddingSize(SignatureType type);
+
+enum class TitleKeyType : u8 {
+    Common = 0,
+    Personalized = 1,
+};
+
+struct TicketData {
+    std::array<u8, 0x40> issuer;
+    union {
+        std::array<u8, 0x100> title_key_block;
+
+        struct {
+            Key128 title_key_common;
+            std::array<u8, 0xF0> title_key_common_pad;
+        };
+    };
+
+    INSERT_PADDING_BYTES(0x1);
+    TitleKeyType type;
+    INSERT_PADDING_BYTES(0x3);
+    u8 revision;
+    INSERT_PADDING_BYTES(0xA);
+    u64 ticket_id;
+    u64 device_id;
+    std::array<u8, 0x10> rights_id;
+    u32 account_id;
+    INSERT_PADDING_BYTES(0x14C);
+};
+static_assert(sizeof(TicketData) == 0x2C0, "TicketData has incorrect size.");
+
+struct RSA4096Ticket {
+    SignatureType sig_type;
+    std::array<u8, 0x200> sig_data;
+    INSERT_PADDING_BYTES(0x3C);
+    TicketData data;
+};
+
+struct RSA2048Ticket {
+    SignatureType sig_type;
+    std::array<u8, 0x100> sig_data;
+    INSERT_PADDING_BYTES(0x3C);
+    TicketData data;
+};
+
+struct ECDSATicket {
+    SignatureType sig_type;
+    std::array<u8, 0x3C> sig_data;
+    INSERT_PADDING_BYTES(0x40);
+    TicketData data;
+};
+
+struct Ticket {
+    std::variant<RSA4096Ticket, RSA2048Ticket, ECDSATicket> data;
+
+    SignatureType GetSignatureType() const;
+    TicketData& GetData();
+    const TicketData& GetData() const;
+    u64 GetSize() const;
+
+    static Ticket SynthesizeCommon(Key128 title_key, const std::array<u8, 0x10>& rights_id);
+};
 
 static_assert(sizeof(Key128) == 16, "Key128 must be 128 bytes big.");
 static_assert(sizeof(Key256) == 32, "Key256 must be 256 bytes big.");
@@ -43,6 +117,19 @@ struct RSAKeyPair {
     std::array<u8, 4> exponent;
 };
 
+template <size_t bit_size, size_t byte_size>
+bool operator==(const RSAKeyPair<bit_size, byte_size>& lhs,
+                const RSAKeyPair<bit_size, byte_size>& rhs) {
+    return std::tie(lhs.encryption_key, lhs.decryption_key, lhs.modulus, lhs.exponent) ==
+           std::tie(rhs.encryption_key, rhs.decryption_key, rhs.modulus, rhs.exponent);
+}
+
+template <size_t bit_size, size_t byte_size>
+bool operator!=(const RSAKeyPair<bit_size, byte_size>& lhs,
+                const RSAKeyPair<bit_size, byte_size>& rhs) {
+    return !(lhs == rhs);
+}
+
 enum class KeyCategory : u8 {
     Standard,
     Title,
@@ -151,22 +238,35 @@ public:
 
     static bool KeyFileExists(bool title);
 
-    // Call before using the sd seed to attempt to derive it if it dosen't exist. Needs system save
-    // 8*43 and the private file to exist.
+    // Call before using the sd seed to attempt to derive it if it dosen't exist. Needs system
+    // save 8*43 and the private file to exist.
     void DeriveSDSeedLazy();
 
     bool BaseDeriveNecessary() const;
     void DeriveBase();
     void DeriveETicket(PartitionDataManager& data);
+    void PopulateTickets();
+    void SynthesizeTickets();
 
     void PopulateFromPartitionData(PartitionDataManager& data);
 
+    const std::map<u128, Ticket>& GetCommonTickets() const;
+    const std::map<u128, Ticket>& GetPersonalizedTickets() const;
+
+    bool AddTicketCommon(Ticket raw);
+    bool AddTicketPersonalized(Ticket raw);
+
 private:
     std::map<KeyIndex<S128KeyType>, Key128> s128_keys;
     std::map<KeyIndex<S256KeyType>, Key256> s256_keys;
 
+    // Map from rights ID to ticket
+    std::map<u128, Ticket> common_tickets;
+    std::map<u128, Ticket> personal_tickets;
+
     std::array<std::array<u8, 0xB0>, 0x20> encrypted_keyblobs{};
     std::array<std::array<u8, 0x90>, 0x20> keyblobs{};
+    std::array<u8, 576> eticket_extended_kek{};
 
     bool dev_mode;
     void LoadFromFile(const std::string& filename, bool is_title_keys);
@@ -178,6 +278,8 @@ private:
 
     void DeriveGeneralPurposeKeys(std::size_t crypto_revision);
 
+    RSAKeyPair<2048> GetETicketRSAKey() const;
+
     void SetKeyWrapped(S128KeyType id, Key128 key, u64 field1 = 0, u64 field2 = 0);
     void SetKeyWrapped(S256KeyType id, Key256 key, u64 field1 = 0, u64 field2 = 0);
 
@@ -195,11 +297,11 @@ std::array<u8, 0x90> DecryptKeyblob(const std::array<u8, 0xB0>& encrypted_keyblo
 std::optional<Key128> DeriveSDSeed();
 Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& keys);
 
-std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save);
+std::vector<Ticket> GetTicketblob(const FileUtil::IOFile& ticket_save);
 
-// Returns a pair of {rights_id, titlekey}. Fails if the ticket has no certificate authority (offset
-// 0x140-0x144 is zero)
-std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
+// Returns a pair of {rights_id, titlekey}. Fails if the ticket has no certificate authority
+// (offset 0x140-0x144 is zero)
+std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
                                                      const RSAKeyPair<2048>& eticket_extended_key);
 
 } // namespace Core::Crypto

src/core/crypto/partition_data_manager.cpp

@@ -480,6 +480,10 @@ void PartitionDataManager::DecryptProdInfo(std::array<u8, 0x20> bis_key) {
     prodinfo_decrypted = std::make_shared<XTSEncryptionLayer>(prodinfo, bis_key);
 }
 
+FileSys::VirtualFile PartitionDataManager::GetDecryptedProdInfo() const {
+    return prodinfo_decrypted;
+}
+
 std::array<u8, 576> PartitionDataManager::GetETicketExtendedKek() const {
     std::array<u8, 0x240> out{};
     if (prodinfo_decrypted != nullptr)

src/core/crypto/partition_data_manager.h

@@ -84,6 +84,7 @@ public:
     bool HasProdInfo() const;
     FileSys::VirtualFile GetProdInfoRaw() const;
     void DecryptProdInfo(std::array<u8, 0x20> bis_key);
+    FileSys::VirtualFile GetDecryptedProdInfo() const;
     std::array<u8, 0x240> GetETicketExtendedKek() const;
 
 private:

src/core/file_sys/bis_factory.cpp

@@ -3,8 +3,12 @@
 // Refer to the license.txt file included.
 
 #include <fmt/format.h>
+#include "common/file_util.h"
+#include "core/core.h"
 #include "core/file_sys/bis_factory.h"
+#include "core/file_sys/mode.h"
 #include "core/file_sys/registered_cache.h"
+#include "core/settings.h"
 
 namespace FileSys {
 
@@ -14,10 +18,22 @@ BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_, VirtualDir
       sysnand_cache(std::make_unique<RegisteredCache>(
           GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
       usrnand_cache(std::make_unique<RegisteredCache>(
-          GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))) {}
+          GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))),
+      sysnand_placeholder(std::make_unique<PlaceholderCache>(
+          GetOrCreateDirectoryRelative(nand_root, "/system/Contents/placehld"))),
+      usrnand_placeholder(std::make_unique<PlaceholderCache>(
+          GetOrCreateDirectoryRelative(nand_root, "/user/Contents/placehld"))) {}
 
 BISFactory::~BISFactory() = default;
 
+VirtualDir BISFactory::GetSystemNANDContentDirectory() const {
+    return GetOrCreateDirectoryRelative(nand_root, "/system/Contents");
+}
+
+VirtualDir BISFactory::GetUserNANDContentDirectory() const {
+    return GetOrCreateDirectoryRelative(nand_root, "/user/Contents");
+}
+
 RegisteredCache* BISFactory::GetSystemNANDContents() const {
     return sysnand_cache.get();
 }
@@ -26,9 +42,17 @@ RegisteredCache* BISFactory::GetUserNANDContents() const {
     return usrnand_cache.get();
 }
 
+PlaceholderCache* BISFactory::GetSystemNANDPlaceholder() const {
+    return sysnand_placeholder.get();
+}
+
+PlaceholderCache* BISFactory::GetUserNANDPlaceholder() const {
+    return usrnand_placeholder.get();
+}
+
 VirtualDir BISFactory::GetModificationLoadRoot(u64 title_id) const {
     // LayeredFS doesn't work on updates and title id-less homebrew
-    if (title_id == 0 || (title_id & 0x800) > 0)
+    if (title_id == 0 || (title_id & 0xFFF) == 0x800)
         return nullptr;
     return GetOrCreateDirectoryRelative(load_root, fmt::format("/{:016X}", title_id));
 }
@@ -39,4 +63,82 @@ VirtualDir BISFactory::GetModificationDumpRoot(u64 title_id) const {
     return GetOrCreateDirectoryRelative(dump_root, fmt::format("/{:016X}", title_id));
 }
 
+VirtualDir BISFactory::OpenPartition(BisPartitionId id) const {
+    switch (id) {
+    case BisPartitionId::CalibrationFile:
+        return GetOrCreateDirectoryRelative(nand_root, "/prodinfof");
+    case BisPartitionId::SafeMode:
+        return GetOrCreateDirectoryRelative(nand_root, "/safe");
+    case BisPartitionId::System:
+        return GetOrCreateDirectoryRelative(nand_root, "/system");
+    case BisPartitionId::User:
+        return GetOrCreateDirectoryRelative(nand_root, "/user");
+    default:
+        return nullptr;
+    }
+}
+
+VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id) const {
+    Core::Crypto::KeyManager keys;
+    Core::Crypto::PartitionDataManager pdm{
+        Core::System::GetInstance().GetFilesystem()->OpenDirectory(
+            FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir), Mode::Read)};
+    keys.PopulateFromPartitionData(pdm);
+
+    switch (id) {
+    case BisPartitionId::CalibrationBinary:
+        return pdm.GetDecryptedProdInfo();
+    case BisPartitionId::BootConfigAndPackage2Part1:
+    case BisPartitionId::BootConfigAndPackage2Part2:
+    case BisPartitionId::BootConfigAndPackage2Part3:
+    case BisPartitionId::BootConfigAndPackage2Part4:
+    case BisPartitionId::BootConfigAndPackage2Part5:
+    case BisPartitionId::BootConfigAndPackage2Part6: {
+        const auto new_id = static_cast<u8>(id) -
+                            static_cast<u8>(BisPartitionId::BootConfigAndPackage2Part1) +
+                            static_cast<u8>(Core::Crypto::Package2Type::NormalMain);
+        return pdm.GetPackage2Raw(static_cast<Core::Crypto::Package2Type>(new_id));
+    }
+    default:
+        return nullptr;
+    }
+}
+
+VirtualDir BISFactory::GetImageDirectory() const {
+    return GetOrCreateDirectoryRelative(nand_root, "/user/Album");
+}
+
+u64 BISFactory::GetSystemNANDFreeSpace() const {
+    const auto sys_dir = GetOrCreateDirectoryRelative(nand_root, "/system");
+    if (sys_dir == nullptr)
+        return 0;
+
+    return GetSystemNANDTotalSpace() - sys_dir->GetSize();
+}
+
+u64 BISFactory::GetSystemNANDTotalSpace() const {
+    return static_cast<u64>(Settings::values.nand_system_size);
+}
+
+u64 BISFactory::GetUserNANDFreeSpace() const {
+    const auto usr_dir = GetOrCreateDirectoryRelative(nand_root, "/user");
+    if (usr_dir == nullptr)
+        return 0;
+
+    return GetUserNANDTotalSpace() - usr_dir->GetSize();
+}
+
+u64 BISFactory::GetUserNANDTotalSpace() const {
+    return static_cast<u64>(Settings::values.nand_user_size);
+}
+
+u64 BISFactory::GetFullNANDTotalSpace() const {
+    return static_cast<u64>(Settings::values.nand_total_size);
+}
+
+VirtualDir BISFactory::GetBCATDirectory(u64 title_id) const {
+    return GetOrCreateDirectoryRelative(nand_root,
+                                        fmt::format("/system/save/bcat/{:016X}", title_id));
+}
+
 } // namespace FileSys

src/core/file_sys/bis_factory.h

@@ -10,7 +10,25 @@
 
 namespace FileSys {
 
+enum class BisPartitionId : u32 {
+    UserDataRoot = 20,
+    CalibrationBinary = 27,
+    CalibrationFile = 28,
+    BootConfigAndPackage2Part1 = 21,
+    BootConfigAndPackage2Part2 = 22,
+    BootConfigAndPackage2Part3 = 23,
+    BootConfigAndPackage2Part4 = 24,
+    BootConfigAndPackage2Part5 = 25,
+    BootConfigAndPackage2Part6 = 26,
+    SafeMode = 29,
+    System = 31,
+    SystemProperEncryption = 32,
+    SystemProperPartition = 33,
+    User = 30,
+};
+
 class RegisteredCache;
+class PlaceholderCache;
 
 /// File system interface to the Built-In Storage
 /// This is currently missing accessors to BIS partitions, but seemed like a good place for the NAND
@@ -20,12 +38,31 @@ public:
     explicit BISFactory(VirtualDir nand_root, VirtualDir load_root, VirtualDir dump_root);
     ~BISFactory();
 
+    VirtualDir GetSystemNANDContentDirectory() const;
+    VirtualDir GetUserNANDContentDirectory() const;
+
     RegisteredCache* GetSystemNANDContents() const;
     RegisteredCache* GetUserNANDContents() const;
 
+    PlaceholderCache* GetSystemNANDPlaceholder() const;
+    PlaceholderCache* GetUserNANDPlaceholder() const;
+
     VirtualDir GetModificationLoadRoot(u64 title_id) const;
     VirtualDir GetModificationDumpRoot(u64 title_id) const;
 
+    VirtualDir OpenPartition(BisPartitionId id) const;
+    VirtualFile OpenPartitionStorage(BisPartitionId id) const;
+
+    VirtualDir GetImageDirectory() const;
+
+    u64 GetSystemNANDFreeSpace() const;
+    u64 GetSystemNANDTotalSpace() const;
+    u64 GetUserNANDFreeSpace() const;
+    u64 GetUserNANDTotalSpace() const;
+    u64 GetFullNANDTotalSpace() const;
+
+    VirtualDir GetBCATDirectory(u64 title_id) const;
+
 private:
     VirtualDir nand_root;
     VirtualDir load_root;
@@ -33,6 +70,9 @@ private:
 
     std::unique_ptr<RegisteredCache> sysnand_cache;
     std::unique_ptr<RegisteredCache> usrnand_cache;
+
+    std::unique_ptr<PlaceholderCache> sysnand_placeholder;
+    std::unique_ptr<PlaceholderCache> usrnand_placeholder;
 };
 
 } // namespace FileSys

src/core/file_sys/card_image.cpp

@@ -12,12 +12,16 @@
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
+#include "core/file_sys/romfs.h"
 #include "core/file_sys/submission_package.h"
+#include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_offset.h"
+#include "core/file_sys/vfs_vector.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
 
+constexpr u64 GAMECARD_CERTIFICATE_OFFSET = 0x7000;
 constexpr std::array partition_names{
     "update",
     "normal",
@@ -27,7 +31,7 @@ constexpr std::array partition_names{
 
 XCI::XCI(VirtualFile file_)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(partition_names.size()) {
+      partitions(partition_names.size()), partitions_raw(partition_names.size()) {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
         status = Loader::ResultStatus::ErrorBadXCIHeader;
         return;
@@ -38,8 +42,10 @@ XCI::XCI(VirtualFile file_)
         return;
     }
 
-    PartitionFilesystem main_hfs(
-        std::make_shared<OffsetVfsFile>(file, header.hfs_size, header.hfs_offset));
+    PartitionFilesystem main_hfs(std::make_shared<OffsetVfsFile>(
+        file, file->GetSize() - header.hfs_offset, header.hfs_offset));
+
+    update_normal_partition_end = main_hfs.GetFileOffsets()["secure"];
 
     if (main_hfs.GetStatus() != Loader::ResultStatus::Success) {
         status = main_hfs.GetStatus();
@@ -51,9 +57,7 @@ XCI::XCI(VirtualFile file_)
         const auto partition_idx = static_cast<std::size_t>(partition);
         auto raw = main_hfs.GetFile(partition_names[partition_idx]);
 
-        if (raw != nullptr) {
-            partitions[partition_idx] = std::make_shared<PartitionFilesystem>(std::move(raw));
-        }
+        partitions_raw[static_cast<std::size_t>(partition)] = raw;
     }
 
     secure_partition = std::make_shared<NSP>(
@@ -67,13 +71,7 @@ XCI::XCI(VirtualFile file_)
         program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
     }
 
-    auto result = AddNCAFromPartition(XCIPartition::Update);
-    if (result != Loader::ResultStatus::Success) {
-        status = result;
-        return;
-    }
-
-    result = AddNCAFromPartition(XCIPartition::Normal);
+    auto result = AddNCAFromPartition(XCIPartition::Normal);
     if (result != Loader::ResultStatus::Success) {
         status = result;
         return;
@@ -100,34 +98,114 @@ Loader::ResultStatus XCI::GetProgramNCAStatus() const {
     return program_nca_status;
 }
 
-VirtualDir XCI::GetPartition(XCIPartition partition) const {
+VirtualDir XCI::GetPartition(XCIPartition partition) {
+    const auto id = static_cast<std::size_t>(partition);
+    if (partitions[id] == nullptr && partitions_raw[id] != nullptr) {
+        partitions[id] = std::make_shared<PartitionFilesystem>(partitions_raw[id]);
+    }
+
     return partitions[static_cast<std::size_t>(partition)];
 }
 
+std::vector<VirtualDir> XCI::GetPartitions() {
+    std::vector<VirtualDir> out;
+    for (const auto& id :
+         {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
+        const auto part = GetPartition(id);
+        if (part != nullptr) {
+            out.push_back(part);
+        }
+    }
+    return out;
+}
+
 std::shared_ptr<NSP> XCI::GetSecurePartitionNSP() const {
     return secure_partition;
 }
 
-VirtualDir XCI::GetSecurePartition() const {
+VirtualDir XCI::GetSecurePartition() {
     return GetPartition(XCIPartition::Secure);
 }
 
-VirtualDir XCI::GetNormalPartition() const {
+VirtualDir XCI::GetNormalPartition() {
     return GetPartition(XCIPartition::Normal);
 }
 
-VirtualDir XCI::GetUpdatePartition() const {
+VirtualDir XCI::GetUpdatePartition() {
     return GetPartition(XCIPartition::Update);
 }
 
-VirtualDir XCI::GetLogoPartition() const {
+VirtualDir XCI::GetLogoPartition() {
     return GetPartition(XCIPartition::Logo);
 }
 
+VirtualFile XCI::GetPartitionRaw(XCIPartition partition) const {
+    return partitions_raw[static_cast<std::size_t>(partition)];
+}
+
+VirtualFile XCI::GetSecurePartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Secure);
+}
+
+VirtualFile XCI::GetStoragePartition0() const {
+    return std::make_shared<OffsetVfsFile>(file, update_normal_partition_end, 0, "partition0");
+}
+
+VirtualFile XCI::GetStoragePartition1() const {
+    return std::make_shared<OffsetVfsFile>(file, file->GetSize() - update_normal_partition_end,
+                                           update_normal_partition_end, "partition1");
+}
+
+VirtualFile XCI::GetNormalPartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Normal);
+}
+
+VirtualFile XCI::GetUpdatePartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Update);
+}
+
+VirtualFile XCI::GetLogoPartitionRaw() const {
+    return GetPartitionRaw(XCIPartition::Logo);
+}
+
 u64 XCI::GetProgramTitleID() const {
     return secure_partition->GetProgramTitleID();
 }
 
+u32 XCI::GetSystemUpdateVersion() {
+    const auto update = GetPartition(XCIPartition::Update);
+    if (update == nullptr)
+        return 0;
+
+    for (const auto& file : update->GetFiles()) {
+        NCA nca{file, nullptr, 0, keys};
+
+        if (nca.GetStatus() != Loader::ResultStatus::Success)
+            continue;
+
+        if (nca.GetType() == NCAContentType::Meta && nca.GetTitleId() == 0x0100000000000816) {
+            const auto dir = nca.GetSubdirectories()[0];
+            const auto cnmt = dir->GetFile("SystemUpdate_0100000000000816.cnmt");
+            if (cnmt == nullptr)
+                continue;
+
+            CNMT cnmt_data{cnmt};
+
+            const auto metas = cnmt_data.GetMetaRecords();
+            if (metas.empty())
+                continue;
+
+            return metas[0].title_version;
+        }
+    }
+
+    return 0;
+}
+
+u64 XCI::GetSystemUpdateTitleID() const {
+    return 0x0100000000000816;
+}
+
 bool XCI::HasProgramNCA() const {
     return program != nullptr;
 }
@@ -175,9 +253,29 @@ VirtualDir XCI::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+VirtualDir XCI::ConcatenatedPseudoDirectory() {
+    const auto out = std::make_shared<VectorVfsDirectory>();
+    for (const auto& part_id : {XCIPartition::Normal, XCIPartition::Logo, XCIPartition::Secure}) {
+        const auto& part = GetPartition(part_id);
+        if (part == nullptr)
+            continue;
+
+        for (const auto& file : part->GetFiles())
+            out->AddFile(file);
+    }
+
+    return out;
+}
+
+std::array<u8, 0x200> XCI::GetCertificate() const {
+    std::array<u8, 0x200> out;
+    file->Read(out.data(), out.size(), GAMECARD_CERTIFICATE_OFFSET);
+    return out;
+}
+
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     const auto partition_index = static_cast<std::size_t>(part);
-    const auto& partition = partitions[partition_index];
+    const auto partition = GetPartition(part);
 
     if (partition == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;
@@ -208,7 +306,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     return Loader::ResultStatus::Success;
 }
 
-u8 XCI::GetFormatVersion() const {
+u8 XCI::GetFormatVersion() {
     return GetLogoPartition() == nullptr ? 0x1 : 0x2;
 }
 } // namespace FileSys

src/core/file_sys/card_image.h

@@ -81,16 +81,28 @@ public:
     Loader::ResultStatus GetStatus() const;
     Loader::ResultStatus GetProgramNCAStatus() const;
 
-    u8 GetFormatVersion() const;
+    u8 GetFormatVersion();
+
+    VirtualDir GetPartition(XCIPartition partition);
+    std::vector<VirtualDir> GetPartitions();
 
-    VirtualDir GetPartition(XCIPartition partition) const;
     std::shared_ptr<NSP> GetSecurePartitionNSP() const;
-    VirtualDir GetSecurePartition() const;
-    VirtualDir GetNormalPartition() const;
-    VirtualDir GetUpdatePartition() const;
-    VirtualDir GetLogoPartition() const;
+    VirtualDir GetSecurePartition();
+    VirtualDir GetNormalPartition();
+    VirtualDir GetUpdatePartition();
+    VirtualDir GetLogoPartition();
+
+    VirtualFile GetPartitionRaw(XCIPartition partition) const;
+    VirtualFile GetSecurePartitionRaw() const;
+    VirtualFile GetStoragePartition0() const;
+    VirtualFile GetStoragePartition1() const;
+    VirtualFile GetNormalPartitionRaw() const;
+    VirtualFile GetUpdatePartitionRaw() const;
+    VirtualFile GetLogoPartitionRaw() const;
 
     u64 GetProgramTitleID() const;
+    u32 GetSystemUpdateVersion();
+    u64 GetSystemUpdateTitleID() const;
 
     bool HasProgramNCA() const;
     VirtualFile GetProgramNCAFile() const;
@@ -106,6 +118,11 @@ public:
 
     VirtualDir GetParentDirectory() const override;
 
+    // Creates a directory that contains all the NCAs in the gamecard
+    VirtualDir ConcatenatedPseudoDirectory();
+
+    std::array<u8, 0x200> GetCertificate() const;
+
 private:
     Loader::ResultStatus AddNCAFromPartition(XCIPartition part);
 
@@ -116,10 +133,13 @@ private:
     Loader::ResultStatus program_nca_status;
 
     std::vector<VirtualDir> partitions;
+    std::vector<VirtualFile> partitions_raw;
     std::shared_ptr<NSP> secure_partition;
     std::shared_ptr<NCA> program;
     std::vector<std::shared_ptr<NCA>> ncas;
 
+    u64 update_normal_partition_end;
+
     Core::Crypto::KeyManager keys;
 };
 } // namespace FileSys

src/core/file_sys/cheat_engine.cpp

@@ -1,492 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <locale>
-#include "common/hex_util.h"
-#include "common/microprofile.h"
-#include "common/swap.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"
-#include "core/file_sys/cheat_engine.h"
-#include "core/hle/kernel/process.h"
-#include "core/hle/service/hid/controllers/npad.h"
-#include "core/hle/service/hid/hid.h"
-#include "core/hle/service/sm/sm.h"
-
-namespace FileSys {
-
-constexpr s64 CHEAT_ENGINE_TICKS = static_cast<s64>(Core::Timing::BASE_CLOCK_RATE / 60);
-constexpr u32 KEYPAD_BITMASK = 0x3FFFFFF;
-
-u64 Cheat::Address() const {
-    u64 out;
-    std::memcpy(&out, raw.data(), sizeof(u64));
-    return Common::swap64(out) & 0xFFFFFFFFFF;
-}
-
-u64 Cheat::ValueWidth(u64 offset) const {
-    return Value(offset, width);
-}
-
-u64 Cheat::Value(u64 offset, u64 width) const {
-    u64 out;
-    std::memcpy(&out, raw.data() + offset, sizeof(u64));
-    out = Common::swap64(out);
-    if (width == 8)
-        return out;
-    return out & ((1ull << (width * CHAR_BIT)) - 1);
-}
-
-u32 Cheat::KeypadValue() const {
-    u32 out;
-    std::memcpy(&out, raw.data(), sizeof(u32));
-    return Common::swap32(out) & 0x0FFFFFFF;
-}
-
-void CheatList::SetMemoryParameters(VAddr main_begin, VAddr heap_begin, VAddr main_end,
-                                    VAddr heap_end, MemoryWriter writer, MemoryReader reader) {
-    this->main_region_begin = main_begin;
-    this->main_region_end = main_end;
-    this->heap_region_begin = heap_begin;
-    this->heap_region_end = heap_end;
-    this->writer = writer;
-    this->reader = reader;
-}
-
-MICROPROFILE_DEFINE(Cheat_Engine, "Add-Ons", "Cheat Engine", MP_RGB(70, 200, 70));
-
-void CheatList::Execute() {
-    MICROPROFILE_SCOPE(Cheat_Engine);
-
-    std::fill(scratch.begin(), scratch.end(), 0);
-    in_standard = false;
-    for (std::size_t i = 0; i < master_list.size(); ++i) {
-        LOG_DEBUG(Common_Filesystem, "Executing block #{:08X} ({})", i, master_list[i].first);
-        current_block = i;
-        ExecuteBlock(master_list[i].second);
-    }
-
-    in_standard = true;
-    for (std::size_t i = 0; i < standard_list.size(); ++i) {
-        LOG_DEBUG(Common_Filesystem, "Executing block #{:08X} ({})", i, standard_list[i].first);
-        current_block = i;
-        ExecuteBlock(standard_list[i].second);
-    }
-}
-
-CheatList::CheatList(const Core::System& system_, ProgramSegment master, ProgramSegment standard)
-    : master_list{std::move(master)}, standard_list{std::move(standard)}, system{&system_} {}
-
-bool CheatList::EvaluateConditional(const Cheat& cheat) const {
-    using ComparisonFunction = bool (*)(u64, u64);
-    constexpr std::array<ComparisonFunction, 6> comparison_functions{
-        [](u64 a, u64 b) { return a > b; },  [](u64 a, u64 b) { return a >= b; },
-        [](u64 a, u64 b) { return a < b; },  [](u64 a, u64 b) { return a <= b; },
-        [](u64 a, u64 b) { return a == b; }, [](u64 a, u64 b) { return a != b; },
-    };
-
-    if (cheat.type == CodeType::ConditionalInput) {
-        const auto applet_resource =
-            system->ServiceManager().GetService<Service::HID::Hid>("hid")->GetAppletResource();
-        if (applet_resource == nullptr) {
-            LOG_WARNING(
-                Common_Filesystem,
-                "Attempted to evaluate input conditional, but applet resource is not initialized!");
-            return false;
-        }
-
-        const auto press_state =
-            applet_resource
-                ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad)
-                .GetAndResetPressState();
-        return ((press_state & cheat.KeypadValue()) & KEYPAD_BITMASK) != 0;
-    }
-
-    ASSERT(cheat.type == CodeType::Conditional);
-
-    const auto offset =
-        cheat.memory_type == MemoryType::MainNSO ? main_region_begin : heap_region_begin;
-    ASSERT(static_cast<u8>(cheat.comparison_op.Value()) < 6);
-    auto* function = comparison_functions[static_cast<u8>(cheat.comparison_op.Value())];
-    const auto addr = cheat.Address() + offset;
-
-    return function(reader(cheat.width, SanitizeAddress(addr)), cheat.ValueWidth(8));
-}
-
-void CheatList::ProcessBlockPairs(const Block& block) {
-    block_pairs.clear();
-
-    u64 scope = 0;
-    std::map<u64, u64> pairs;
-
-    for (std::size_t i = 0; i < block.size(); ++i) {
-        const auto& cheat = block[i];
-
-        switch (cheat.type) {
-        case CodeType::Conditional:
-        case CodeType::ConditionalInput:
-            pairs.insert_or_assign(scope, i);
-            ++scope;
-            break;
-        case CodeType::EndConditional: {
-            --scope;
-            const auto idx = pairs.at(scope);
-            block_pairs.insert_or_assign(idx, i);
-            break;
-        }
-        case CodeType::Loop: {
-            if (cheat.end_of_loop) {
-                --scope;
-                const auto idx = pairs.at(scope);
-                block_pairs.insert_or_assign(idx, i);
-            } else {
-                pairs.insert_or_assign(scope, i);
-                ++scope;
-            }
-            break;
-        }
-        }
-    }
-}
-
-void CheatList::WriteImmediate(const Cheat& cheat) {
-    const auto offset =
-        cheat.memory_type == MemoryType::MainNSO ? main_region_begin : heap_region_begin;
-    const auto& register_3 = scratch.at(cheat.register_3);
-
-    const auto addr = cheat.Address() + offset + register_3;
-    LOG_DEBUG(Common_Filesystem, "writing value={:016X} to addr={:016X}", addr,
-              cheat.Value(8, cheat.width));
-    writer(cheat.width, SanitizeAddress(addr), cheat.ValueWidth(8));
-}
-
-void CheatList::BeginConditional(const Cheat& cheat) {
-    if (EvaluateConditional(cheat)) {
-        return;
-    }
-
-    const auto iter = block_pairs.find(current_index);
-    ASSERT(iter != block_pairs.end());
-    current_index = iter->second - 1;
-}
-
-void CheatList::EndConditional(const Cheat& cheat) {
-    LOG_DEBUG(Common_Filesystem, "Ending conditional block.");
-}
-
-void CheatList::Loop(const Cheat& cheat) {
-    if (cheat.end_of_loop.Value())
-        ASSERT(!cheat.end_of_loop.Value());
-
-    auto& register_3 = scratch.at(cheat.register_3);
-    const auto iter = block_pairs.find(current_index);
-    ASSERT(iter != block_pairs.end());
-    ASSERT(iter->first < iter->second);
-
-    const s32 initial_value = static_cast<s32>(cheat.Value(4, sizeof(s32)));
-    for (s32 i = initial_value; i >= 0; --i) {
-        register_3 = static_cast<u64>(i);
-        for (std::size_t c = iter->first + 1; c < iter->second; ++c) {
-            current_index = c;
-            ExecuteSingleCheat(
-                (in_standard ? standard_list : master_list)[current_block].second[c]);
-        }
-    }
-
-    current_index = iter->second;
-}
-
-void CheatList::LoadImmediate(const Cheat& cheat) {
-    auto& register_3 = scratch.at(cheat.register_3);
-
-    LOG_DEBUG(Common_Filesystem, "setting register={:01X} equal to value={:016X}", cheat.register_3,
-              cheat.Value(4, 8));
-    register_3 = cheat.Value(4, 8);
-}
-
-void CheatList::LoadIndexed(const Cheat& cheat) {
-    const auto offset =
-        cheat.memory_type == MemoryType::MainNSO ? main_region_begin : heap_region_begin;
-    auto& register_3 = scratch.at(cheat.register_3);
-
-    const auto addr = (cheat.load_from_register.Value() ? register_3 : offset) + cheat.Address();
-    LOG_DEBUG(Common_Filesystem, "writing indexed value to register={:01X}, addr={:016X}",
-              cheat.register_3, addr);
-    register_3 = reader(cheat.width, SanitizeAddress(addr));
-}
-
-void CheatList::StoreIndexed(const Cheat& cheat) {
-    const auto& register_3 = scratch.at(cheat.register_3);
-
-    const auto addr =
-        register_3 + (cheat.add_additional_register.Value() ? scratch.at(cheat.register_6) : 0);
-    LOG_DEBUG(Common_Filesystem, "writing value={:016X} to addr={:016X}",
-              cheat.Value(4, cheat.width), addr);
-    writer(cheat.width, SanitizeAddress(addr), cheat.ValueWidth(4));
-}
-
-void CheatList::RegisterArithmetic(const Cheat& cheat) {
-    using ArithmeticFunction = u64 (*)(u64, u64);
-    constexpr std::array<ArithmeticFunction, 5> arithmetic_functions{
-        [](u64 a, u64 b) { return a + b; },  [](u64 a, u64 b) { return a - b; },
-        [](u64 a, u64 b) { return a * b; },  [](u64 a, u64 b) { return a << b; },
-        [](u64 a, u64 b) { return a >> b; },
-    };
-
-    using ArithmeticOverflowCheck = bool (*)(u64, u64);
-    constexpr std::array<ArithmeticOverflowCheck, 5> arithmetic_overflow_checks{
-        [](u64 a, u64 b) { return a > (std::numeric_limits<u64>::max() - b); },       // a + b
-        [](u64 a, u64 b) { return a > (std::numeric_limits<u64>::max() + b); },       // a - b
-        [](u64 a, u64 b) { return a > (std::numeric_limits<u64>::max() / b); },       // a * b
-        [](u64 a, u64 b) { return b >= 64 || (a & ~((1ull << (64 - b)) - 1)) != 0; }, // a << b
-        [](u64 a, u64 b) { return b >= 64 || (a & ((1ull << b) - 1)) != 0; },         // a >> b
-    };
-
-    static_assert(sizeof(arithmetic_functions) == sizeof(arithmetic_overflow_checks),
-                  "Missing or have extra arithmetic overflow checks compared to functions!");
-
-    auto& register_3 = scratch.at(cheat.register_3);
-
-    ASSERT(static_cast<u8>(cheat.arithmetic_op.Value()) < 5);
-    auto* function = arithmetic_functions[static_cast<u8>(cheat.arithmetic_op.Value())];
-    auto* overflow_function =
-        arithmetic_overflow_checks[static_cast<u8>(cheat.arithmetic_op.Value())];
-    LOG_DEBUG(Common_Filesystem, "performing arithmetic with register={:01X}, value={:016X}",
-              cheat.register_3, cheat.ValueWidth(4));
-
-    if (overflow_function(register_3, cheat.ValueWidth(4))) {
-        LOG_WARNING(Common_Filesystem,
-                    "overflow will occur when performing arithmetic operation={:02X} with operands "
-                    "a={:016X}, b={:016X}!",
-                    static_cast<u8>(cheat.arithmetic_op.Value()), register_3, cheat.ValueWidth(4));
-    }
-
-    register_3 = function(register_3, cheat.ValueWidth(4));
-}
-
-void CheatList::BeginConditionalInput(const Cheat& cheat) {
-    if (EvaluateConditional(cheat))
-        return;
-
-    const auto iter = block_pairs.find(current_index);
-    ASSERT(iter != block_pairs.end());
-    current_index = iter->second - 1;
-}
-
-VAddr CheatList::SanitizeAddress(VAddr in) const {
-    if ((in < main_region_begin || in >= main_region_end) &&
-        (in < heap_region_begin || in >= heap_region_end)) {
-        LOG_ERROR(Common_Filesystem,
-                  "Cheat attempting to access memory at invalid address={:016X}, if this persists, "
-                  "the cheat may be incorrect. However, this may be normal early in execution if "
-                  "the game has not properly set up yet.",
-                  in);
-        return 0; ///< Invalid addresses will hard crash
-    }
-
-    return in;
-}
-
-void CheatList::ExecuteSingleCheat(const Cheat& cheat) {
-    using CheatOperationFunction = void (CheatList::*)(const Cheat&);
-    constexpr std::array<CheatOperationFunction, 9> cheat_operation_functions{
-        &CheatList::WriteImmediate,        &CheatList::BeginConditional,
-        &CheatList::EndConditional,        &CheatList::Loop,
-        &CheatList::LoadImmediate,         &CheatList::LoadIndexed,
-        &CheatList::StoreIndexed,          &CheatList::RegisterArithmetic,
-        &CheatList::BeginConditionalInput,
-    };
-
-    const auto index = static_cast<u8>(cheat.type.Value());
-    ASSERT(index < sizeof(cheat_operation_functions));
-    const auto op = cheat_operation_functions[index];
-    (this->*op)(cheat);
-}
-
-void CheatList::ExecuteBlock(const Block& block) {
-    encountered_loops.clear();
-
-    ProcessBlockPairs(block);
-    for (std::size_t i = 0; i < block.size(); ++i) {
-        current_index = i;
-        ExecuteSingleCheat(block[i]);
-        i = current_index;
-    }
-}
-
-CheatParser::~CheatParser() = default;
-
-CheatList CheatParser::MakeCheatList(const Core::System& system, CheatList::ProgramSegment master,
-                                     CheatList::ProgramSegment standard) const {
-    return {system, std::move(master), std::move(standard)};
-}
-
-TextCheatParser::~TextCheatParser() = default;
-
-CheatList TextCheatParser::Parse(const Core::System& system, const std::vector<u8>& data) const {
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char*>(data.data()), data.size());
-
-    std::vector<std::string> lines;
-    std::string stream_line;
-    while (std::getline(ss, stream_line)) {
-        // Remove a trailing \r
-        if (!stream_line.empty() && stream_line.back() == '\r')
-            stream_line.pop_back();
-        lines.push_back(std::move(stream_line));
-    }
-
-    CheatList::ProgramSegment master_list;
-    CheatList::ProgramSegment standard_list;
-
-    for (std::size_t i = 0; i < lines.size(); ++i) {
-        auto line = lines[i];
-
-        if (!line.empty() && (line[0] == '[' || line[0] == '{')) {
-            const auto master = line[0] == '{';
-            const auto begin = master ? line.find('{') : line.find('[');
-            const auto end = master ? line.rfind('}') : line.rfind(']');
-
-            ASSERT(begin != std::string::npos && end != std::string::npos);
-
-            const std::string patch_name{line.begin() + begin + 1, line.begin() + end};
-            CheatList::Block block{};
-
-            while (i < lines.size() - 1) {
-                line = lines[++i];
-                if (!line.empty() && (line[0] == '[' || line[0] == '{')) {
-                    --i;
-                    break;
-                }
-
-                if (line.size() < 8)
-                    continue;
-
-                Cheat out{};
-                out.raw = ParseSingleLineCheat(line);
-                block.push_back(out);
-            }
-
-            (master ? master_list : standard_list).emplace_back(patch_name, block);
-        }
-    }
-
-    return MakeCheatList(system, master_list, standard_list);
-}
-
-std::array<u8, 16> TextCheatParser::ParseSingleLineCheat(const std::string& line) const {
-    std::array<u8, 16> out{};
-
-    if (line.size() < 8)
-        return out;
-
-    const auto word1 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data(), 8});
-    std::memcpy(out.data(), word1.data(), sizeof(u32));
-
-    if (line.size() < 17 || line[8] != ' ')
-        return out;
-
-    const auto word2 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data() + 9, 8});
-    std::memcpy(out.data() + sizeof(u32), word2.data(), sizeof(u32));
-
-    if (line.size() < 26 || line[17] != ' ') {
-        // Perform shifting in case value is truncated early.
-        const auto type = static_cast<CodeType>((out[0] & 0xF0) >> 4);
-        if (type == CodeType::Loop || type == CodeType::LoadImmediate ||
-            type == CodeType::StoreIndexed || type == CodeType::RegisterArithmetic) {
-            std::memcpy(out.data() + 8, out.data() + 4, sizeof(u32));
-            std::memset(out.data() + 4, 0, sizeof(u32));
-        }
-
-        return out;
-    }
-
-    const auto word3 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data() + 18, 8});
-    std::memcpy(out.data() + 2 * sizeof(u32), word3.data(), sizeof(u32));
-
-    if (line.size() < 35 || line[26] != ' ') {
-        // Perform shifting in case value is truncated early.
-        const auto type = static_cast<CodeType>((out[0] & 0xF0) >> 4);
-        if (type == CodeType::WriteImmediate || type == CodeType::Conditional) {
-            std::memcpy(out.data() + 12, out.data() + 8, sizeof(u32));
-            std::memset(out.data() + 8, 0, sizeof(u32));
-        }
-
-        return out;
-    }
-
-    const auto word4 = Common::HexStringToArray<sizeof(u32)>(std::string_view{line.data() + 27, 8});
-    std::memcpy(out.data() + 3 * sizeof(u32), word4.data(), sizeof(u32));
-
-    return out;
-}
-
-namespace {
-u64 MemoryReadImpl(u32 width, VAddr addr) {
-    switch (width) {
-    case 1:
-        return Memory::Read8(addr);
-    case 2:
-        return Memory::Read16(addr);
-    case 4:
-        return Memory::Read32(addr);
-    case 8:
-        return Memory::Read64(addr);
-    default:
-        UNREACHABLE();
-        return 0;
-    }
-}
-
-void MemoryWriteImpl(u32 width, VAddr addr, u64 value) {
-    switch (width) {
-    case 1:
-        Memory::Write8(addr, static_cast<u8>(value));
-        break;
-    case 2:
-        Memory::Write16(addr, static_cast<u16>(value));
-        break;
-    case 4:
-        Memory::Write32(addr, static_cast<u32>(value));
-        break;
-    case 8:
-        Memory::Write64(addr, value);
-        break;
-    default:
-        UNREACHABLE();
-    }
-}
-} // Anonymous namespace
-
-CheatEngine::CheatEngine(Core::System& system, std::vector<CheatList> cheats_,
-                         const std::string& build_id, VAddr code_region_start,
-                         VAddr code_region_end)
-    : cheats{std::move(cheats_)}, core_timing{system.CoreTiming()} {
-    event = core_timing.RegisterEvent(
-        "CheatEngine::FrameCallback::" + build_id,
-        [this](u64 userdata, s64 cycles_late) { FrameCallback(userdata, cycles_late); });
-    core_timing.ScheduleEvent(CHEAT_ENGINE_TICKS, event);
-
-    const auto& vm_manager = system.CurrentProcess()->VMManager();
-    for (auto& list : this->cheats) {
-        list.SetMemoryParameters(code_region_start, vm_manager.GetHeapRegionBaseAddress(),
-                                 code_region_end, vm_manager.GetHeapRegionEndAddress(),
-                                 &MemoryWriteImpl, &MemoryReadImpl);
-    }
-}
-
-CheatEngine::~CheatEngine() {
-    core_timing.UnscheduleEvent(event, 0);
-}
-
-void CheatEngine::FrameCallback(u64 userdata, s64 cycles_late) {
-    for (auto& list : cheats) {
-        list.Execute();
-    }
-
-    core_timing.ScheduleEvent(CHEAT_ENGINE_TICKS - cycles_late, event);
-}
-
-} // namespace FileSys

src/core/file_sys/cheat_engine.h

@@ -1,234 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include <set>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Core::Timing {
-class CoreTiming;
-struct EventType;
-} // namespace Core::Timing
-
-namespace FileSys {
-
-enum class CodeType : u32 {
-    // 0TMR00AA AAAAAAAA YYYYYYYY YYYYYYYY
-    // Writes a T sized value Y to the address A added to the value of register R in memory domain M
-    WriteImmediate = 0,
-
-    // 1TMC00AA AAAAAAAA YYYYYYYY YYYYYYYY
-    // Compares the T sized value Y to the value at address A in memory domain M using the
-    // conditional function C. If success, continues execution. If failure, jumps to the matching
-    // EndConditional statement.
-    Conditional = 1,
-
-    // 20000000
-    // Terminates a Conditional or ConditionalInput block.
-    EndConditional = 2,
-
-    // 300R0000 VVVVVVVV
-    // Starts looping V times, storing the current count in register R.
-    // Loop block is terminated with a matching 310R0000.
-    Loop = 3,
-
-    // 400R0000 VVVVVVVV VVVVVVVV
-    // Sets the value of register R to the value V.
-    LoadImmediate = 4,
-
-    // 5TMRI0AA AAAAAAAA
-    // Sets the value of register R to the value of width T at address A in memory domain M, with
-    // the current value of R added to the address if I == 1.
-    LoadIndexed = 5,
-
-    // 6T0RIFG0 VVVVVVVV VVVVVVVV
-    // Writes the value V of width T to the memory address stored in register R. Adds the value of
-    // register G to the final calculation if F is nonzero. Increments the value of register R by T
-    // after operation if I is nonzero.
-    StoreIndexed = 6,
-
-    // 7T0RA000 VVVVVVVV
-    // Performs the arithmetic operation A on the value in register R and the value V of width T,
-    // storing the result in register R.
-    RegisterArithmetic = 7,
-
-    // 8KKKKKKK
-    // Checks to see if any of the buttons defined by the bitmask K are pressed. If any are,
-    // execution continues. If none are, execution skips to the next EndConditional command.
-    ConditionalInput = 8,
-};
-
-enum class MemoryType : u32 {
-    // Addressed relative to start of main NSO
-    MainNSO = 0,
-
-    // Addressed relative to start of heap
-    Heap = 1,
-};
-
-enum class ArithmeticOp : u32 {
-    Add = 0,
-    Sub = 1,
-    Mult = 2,
-    LShift = 3,
-    RShift = 4,
-};
-
-enum class ComparisonOp : u32 {
-    GreaterThan = 1,
-    GreaterThanEqual = 2,
-    LessThan = 3,
-    LessThanEqual = 4,
-    Equal = 5,
-    Inequal = 6,
-};
-
-union Cheat {
-    std::array<u8, 16> raw;
-
-    BitField<4, 4, CodeType> type;
-    BitField<0, 4, u32> width; // Can be 1, 2, 4, or 8. Measured in bytes.
-    BitField<0, 4, u32> end_of_loop;
-    BitField<12, 4, MemoryType> memory_type;
-    BitField<8, 4, u32> register_3;
-    BitField<8, 4, ComparisonOp> comparison_op;
-    BitField<20, 4, u32> load_from_register;
-    BitField<20, 4, u32> increment_register;
-    BitField<20, 4, ArithmeticOp> arithmetic_op;
-    BitField<16, 4, u32> add_additional_register;
-    BitField<28, 4, u32> register_6;
-
-    u64 Address() const;
-    u64 ValueWidth(u64 offset) const;
-    u64 Value(u64 offset, u64 width) const;
-    u32 KeypadValue() const;
-};
-
-class CheatParser;
-
-// Represents a full collection of cheats for a game. The Execute function should be called every
-// interval that all cheats should be executed. Clients should not directly instantiate this class
-// (hence private constructor), they should instead receive an instance from CheatParser, which
-// guarantees the list is always in an acceptable state.
-class CheatList {
-public:
-    friend class CheatParser;
-
-    using Block = std::vector<Cheat>;
-    using ProgramSegment = std::vector<std::pair<std::string, Block>>;
-
-    // (width in bytes, address, value)
-    using MemoryWriter = void (*)(u32, VAddr, u64);
-    // (width in bytes, address) -> value
-    using MemoryReader = u64 (*)(u32, VAddr);
-
-    void SetMemoryParameters(VAddr main_begin, VAddr heap_begin, VAddr main_end, VAddr heap_end,
-                             MemoryWriter writer, MemoryReader reader);
-
-    void Execute();
-
-private:
-    CheatList(const Core::System& system_, ProgramSegment master, ProgramSegment standard);
-
-    void ProcessBlockPairs(const Block& block);
-    void ExecuteSingleCheat(const Cheat& cheat);
-
-    void ExecuteBlock(const Block& block);
-
-    bool EvaluateConditional(const Cheat& cheat) const;
-
-    // Individual cheat operations
-    void WriteImmediate(const Cheat& cheat);
-    void BeginConditional(const Cheat& cheat);
-    void EndConditional(const Cheat& cheat);
-    void Loop(const Cheat& cheat);
-    void LoadImmediate(const Cheat& cheat);
-    void LoadIndexed(const Cheat& cheat);
-    void StoreIndexed(const Cheat& cheat);
-    void RegisterArithmetic(const Cheat& cheat);
-    void BeginConditionalInput(const Cheat& cheat);
-
-    VAddr SanitizeAddress(VAddr in) const;
-
-    // Master Codes are defined as codes that cannot be disabled and are run prior to all
-    // others.
-    ProgramSegment master_list;
-    // All other codes
-    ProgramSegment standard_list;
-
-    bool in_standard = false;
-
-    // 16 (0x0-0xF) scratch registers that can be used by cheats
-    std::array<u64, 16> scratch{};
-
-    MemoryWriter writer = nullptr;
-    MemoryReader reader = nullptr;
-
-    u64 main_region_begin{};
-    u64 heap_region_begin{};
-    u64 main_region_end{};
-    u64 heap_region_end{};
-
-    u64 current_block{};
-    // The current index of the cheat within the current Block
-    u64 current_index{};
-
-    // The 'stack' of the program. When a conditional or loop statement is encountered, its index is
-    // pushed onto this queue. When a end block is encountered, the condition is checked.
-    std::map<u64, u64> block_pairs;
-
-    std::set<u64> encountered_loops;
-
-    const Core::System* system;
-};
-
-// Intermediary class that parses a text file or other disk format for storing cheats into a
-// CheatList object, that can be used for execution.
-class CheatParser {
-public:
-    virtual ~CheatParser();
-
-    virtual CheatList Parse(const Core::System& system, const std::vector<u8>& data) const = 0;
-
-protected:
-    CheatList MakeCheatList(const Core::System& system_, CheatList::ProgramSegment master,
-                            CheatList::ProgramSegment standard) const;
-};
-
-// CheatParser implementation that parses text files
-class TextCheatParser final : public CheatParser {
-public:
-    ~TextCheatParser() override;
-
-    CheatList Parse(const Core::System& system, const std::vector<u8>& data) const override;
-
-private:
-    std::array<u8, 16> ParseSingleLineCheat(const std::string& line) const;
-};
-
-// Class that encapsulates a CheatList and manages its interaction with memory and CoreTiming
-class CheatEngine final {
-public:
-    CheatEngine(Core::System& system_, std::vector<CheatList> cheats_, const std::string& build_id,
-                VAddr code_region_start, VAddr code_region_end);
-    ~CheatEngine();
-
-private:
-    void FrameCallback(u64 userdata, s64 cycles_late);
-
-    std::vector<CheatList> cheats;
-
-    Core::Timing::EventType* event;
-    Core::Timing::CoreTiming& core_timing;
-};
-
-} // namespace FileSys

src/core/file_sys/content_archive.cpp

@@ -528,6 +528,14 @@ u64 NCA::GetTitleId() const {
     return header.title_id;
 }
 
+std::array<u8, 16> NCA::GetRightsId() const {
+    return header.rights_id;
+}
+
+u32 NCA::GetSDKVersion() const {
+    return header.sdk_version;
+}
+
 bool NCA::IsUpdate() const {
     return is_update;
 }

src/core/file_sys/content_archive.h

@@ -112,6 +112,8 @@ public:
 
     NCAContentType GetType() const;
     u64 GetTitleId() const;
+    std::array<u8, 0x10> GetRightsId() const;
+    u32 GetSDKVersion() const;
     bool IsUpdate() const;
 
     VirtualFile GetRomFS() const;

src/core/file_sys/partition_filesystem.cpp

@@ -65,6 +65,9 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
         std::string name(
             reinterpret_cast<const char*>(&file_data[strtab_offset + entry.strtab_offset]));
 
+        offsets[name] = content_offset + entry.offset;
+        sizes[name] = entry.size;
+
         pfs_files.emplace_back(std::make_shared<OffsetVfsFile>(
             file, entry.size, content_offset + entry.offset, std::move(name)));
     }
@@ -78,6 +81,14 @@ Loader::ResultStatus PartitionFilesystem::GetStatus() const {
     return status;
 }
 
+std::map<std::string, u64> PartitionFilesystem::GetFileOffsets() const {
+    return offsets;
+}
+
+std::map<std::string, u64> PartitionFilesystem::GetFileSizes() const {
+    return sizes;
+}
+
 std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
     return pfs_files;
 }

src/core/file_sys/partition_filesystem.h

@@ -29,6 +29,9 @@ public:
 
     Loader::ResultStatus GetStatus() const;
 
+    std::map<std::string, u64> GetFileOffsets() const;
+    std::map<std::string, u64> GetFileSizes() const;
+
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
     std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
     std::string GetName() const override;
@@ -80,6 +83,9 @@ private:
     bool is_hfs = false;
     std::size_t content_offset = 0;
 
+    std::map<std::string, u64> offsets;
+    std::map<std::string, u64> sizes;
+
     std::vector<VirtualFile> pfs_files;
 };
 

src/core/file_sys/patch_manager.cpp

@@ -22,6 +22,7 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 #include "core/loader/nso.h"
+#include "core/memory/cheat_engine.h"
 #include "core/settings.h"
 
 namespace FileSys {
@@ -63,7 +64,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 
     if (Settings::values.dump_exefs) {
         LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
-        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
+        const auto dump_dir =
+            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
         if (dump_dir != nullptr) {
             const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
             VfsRawCopyD(exefs, exefs_dir);
@@ -88,7 +90,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     }
 
     // LayeredExeFS
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if (load_dir != nullptr && load_dir->GetSize() > 0) {
         auto patch_dirs = load_dir->GetSubdirectories();
         std::sort(
@@ -174,7 +177,8 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     if (Settings::values.dump_nso) {
         LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
                  title_id);
-        const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
+        const auto dump_dir =
+            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
         if (dump_dir != nullptr) {
             const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
             const auto file = nso_dir->CreateFile(fmt::format("{}-{}.nso", name, build_id));
@@ -186,7 +190,13 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 
     LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
 
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    if (load_dir == nullptr) {
+        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
+        return nso;
+    }
+
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -224,7 +234,13 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
 
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
 
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    if (load_dir == nullptr) {
+        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
+        return false;
+    }
+
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
@@ -232,9 +248,10 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
     return !CollectPatches(patch_dirs, build_id).empty();
 }
 
-static std::optional<CheatList> ReadCheatFileFromFolder(const Core::System& system, u64 title_id,
-                                                        const std::array<u8, 0x20>& build_id_,
-                                                        const VirtualDir& base_path, bool upper) {
+namespace {
+std::optional<std::vector<Memory::CheatEntry>> ReadCheatFileFromFolder(
+    const Core::System& system, u64 title_id, const std::array<u8, 0x20>& build_id_,
+    const VirtualDir& base_path, bool upper) {
     const auto build_id_raw = Common::HexToString(build_id_, upper);
     const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
     const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
@@ -252,31 +269,39 @@ static std::optional<CheatList> ReadCheatFileFromFolder(const Core::System& syst
         return std::nullopt;
     }
 
-    TextCheatParser parser;
-    return parser.Parse(system, data);
+    Memory::TextCheatParser parser;
+    return parser.Parse(
+        system, std::string_view(reinterpret_cast<const char* const>(data.data()), data.size()));
 }
 
-std::vector<CheatList> PatchManager::CreateCheatList(const Core::System& system,
-                                                     const std::array<u8, 32>& build_id_) const {
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+} // Anonymous namespace
+
+std::vector<Memory::CheatEntry> PatchManager::CreateCheatList(
+    const Core::System& system, const std::array<u8, 32>& build_id_) const {
+    const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
+    if (load_dir == nullptr) {
+        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
+        return {};
+    }
+
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(),
               [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
 
-    std::vector<CheatList> out;
-    out.reserve(patch_dirs.size());
+    std::vector<Memory::CheatEntry> out;
     for (const auto& subdir : patch_dirs) {
         auto cheats_dir = subdir->GetSubdirectory("cheats");
         if (cheats_dir != nullptr) {
             auto res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, true);
             if (res.has_value()) {
-                out.push_back(std::move(*res));
+                std::copy(res->begin(), res->end(), std::back_inserter(out));
                 continue;
             }
 
             res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, false);
-            if (res.has_value())
-                out.push_back(std::move(*res));
+            if (res.has_value()) {
+                std::copy(res->begin(), res->end(), std::back_inserter(out));
+            }
         }
     }
 
@@ -284,7 +309,8 @@ std::vector<CheatList> PatchManager::CreateCheatList(const Core::System& system,
 }
 
 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
-    const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    const auto load_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
         load_dir == nullptr || load_dir->GetSize() <= 0) {
         return;
@@ -393,6 +419,8 @@ static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
 
 std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
     VirtualFile update_raw) const {
+    if (title_id == 0)
+        return {};
     std::map<std::string, std::string, std::less<>> out;
     const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto& disabled = Settings::values.disabled_addons[title_id];
@@ -423,7 +451,8 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     }
 
     // General Mods (LayeredFS and IPS)
-    const auto mod_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
+    const auto mod_dir =
+        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
     if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
         for (const auto& mod : mod_dir->GetSubdirectories()) {
             std::string types;

src/core/file_sys/patch_manager.h

@@ -8,9 +8,9 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "core/file_sys/cheat_engine.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/vfs.h"
+#include "core/memory/dmnt_cheat_types.h"
 
 namespace Core {
 class System;
@@ -51,8 +51,8 @@ public:
     bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;
 
     // Creates a CheatList object with all
-    std::vector<CheatList> CreateCheatList(const Core::System& system,
-                                           const std::array<u8, 0x20>& build_id) const;
+    std::vector<Memory::CheatEntry> CreateCheatList(const Core::System& system,
+                                                    const std::array<u8, 0x20>& build_id) const;
 
     // Currently tracked RomFS patches:
     // - Game Updates

src/core/file_sys/registered_cache.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <random>
 #include <regex>
 #include <mbedtls/sha256.h>
 #include "common/assert.h"
@@ -48,18 +49,21 @@ static bool FollowsTwoDigitDirFormat(std::string_view name) {
 static bool FollowsNcaIdFormat(std::string_view name) {
     static const std::regex nca_id_regex("[0-9A-F]{32}\\.nca", std::regex_constants::ECMAScript |
                                                                    std::regex_constants::icase);
-    return name.size() == 36 && std::regex_match(name.begin(), name.end(), nca_id_regex);
+    static const std::regex nca_id_cnmt_regex(
+        "[0-9A-F]{32}\\.cnmt.nca", std::regex_constants::ECMAScript | std::regex_constants::icase);
+    return (name.size() == 36 && std::regex_match(name.begin(), name.end(), nca_id_regex)) ||
+           (name.size() == 41 && std::regex_match(name.begin(), name.end(), nca_id_cnmt_regex));
 }
 
 static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bool second_hex_upper,
-                                            bool within_two_digit) {
-    if (!within_two_digit) {
-        return fmt::format("/{}.nca", Common::HexToString(nca_id, second_hex_upper));
-    }
+                                            bool within_two_digit, bool cnmt_suffix) {
+    if (!within_two_digit)
+        return fmt::format(cnmt_suffix ? "{}.cnmt.nca" : "/{}.nca",
+                           Common::HexToString(nca_id, second_hex_upper));
 
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
-    return fmt::format("/000000{:02X}/{}.nca", hash[0],
+    return fmt::format(cnmt_suffix ? "/000000{:02X}/{}.cnmt.nca" : "/000000{:02X}/{}.nca", hash[0],
                        Common::HexToString(nca_id, second_hex_upper));
 }
 
@@ -127,6 +131,156 @@ std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
     return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
 }
 
+PlaceholderCache::PlaceholderCache(VirtualDir dir_) : dir(std::move(dir_)) {}
+
+bool PlaceholderCache::Create(const NcaID& id, u64 size) const {
+    const auto path = GetRelativePathFromNcaID(id, false, true, false);
+
+    if (dir->GetFileRelative(path) != nullptr) {
+        return false;
+    }
+
+    Core::Crypto::SHA256Hash hash{};
+    mbedtls_sha256(id.data(), id.size(), hash.data(), 0);
+    const auto dirname = fmt::format("000000{:02X}", hash[0]);
+
+    const auto dir2 = GetOrCreateDirectoryRelative(dir, dirname);
+
+    if (dir2 == nullptr)
+        return false;
+
+    const auto file = dir2->CreateFile(fmt::format("{}.nca", Common::HexToString(id, false)));
+
+    if (file == nullptr)
+        return false;
+
+    return file->Resize(size);
+}
+
+bool PlaceholderCache::Delete(const NcaID& id) const {
+    const auto path = GetRelativePathFromNcaID(id, false, true, false);
+
+    if (dir->GetFileRelative(path) == nullptr) {
+        return false;
+    }
+
+    Core::Crypto::SHA256Hash hash{};
+    mbedtls_sha256(id.data(), id.size(), hash.data(), 0);
+    const auto dirname = fmt::format("000000{:02X}", hash[0]);
+
+    const auto dir2 = GetOrCreateDirectoryRelative(dir, dirname);
+
+    const auto res = dir2->DeleteFile(fmt::format("{}.nca", Common::HexToString(id, false)));
+
+    return res;
+}
+
+bool PlaceholderCache::Exists(const NcaID& id) const {
+    const auto path = GetRelativePathFromNcaID(id, false, true, false);
+
+    return dir->GetFileRelative(path) != nullptr;
+}
+
+bool PlaceholderCache::Write(const NcaID& id, u64 offset, const std::vector<u8>& data) const {
+    const auto path = GetRelativePathFromNcaID(id, false, true, false);
+    const auto file = dir->GetFileRelative(path);
+
+    if (file == nullptr)
+        return false;
+
+    return file->WriteBytes(data, offset) == data.size();
+}
+
+bool PlaceholderCache::Register(RegisteredCache* cache, const NcaID& placeholder,
+                                const NcaID& install) const {
+    const auto path = GetRelativePathFromNcaID(placeholder, false, true, false);
+    const auto file = dir->GetFileRelative(path);
+
+    if (file == nullptr)
+        return false;
+
+    const auto res = cache->RawInstallNCA(NCA{file}, &VfsRawCopy, false, install);
+
+    if (res != InstallResult::Success)
+        return false;
+
+    return Delete(placeholder);
+}
+
+bool PlaceholderCache::CleanAll() const {
+    return dir->GetParentDirectory()->CleanSubdirectoryRecursive(dir->GetName());
+}
+
+std::optional<std::array<u8, 0x10>> PlaceholderCache::GetRightsID(const NcaID& id) const {
+    const auto path = GetRelativePathFromNcaID(id, false, true, false);
+    const auto file = dir->GetFileRelative(path);
+
+    if (file == nullptr)
+        return std::nullopt;
+
+    NCA nca{file};
+
+    if (nca.GetStatus() != Loader::ResultStatus::Success &&
+        nca.GetStatus() != Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
+        return std::nullopt;
+    }
+
+    const auto rights_id = nca.GetRightsId();
+    if (rights_id == NcaID{})
+        return std::nullopt;
+
+    return rights_id;
+}
+
+u64 PlaceholderCache::Size(const NcaID& id) const {
+    const auto path = GetRelativePathFromNcaID(id, false, true, false);
+    const auto file = dir->GetFileRelative(path);
+
+    if (file == nullptr)
+        return 0;
+
+    return file->GetSize();
+}
+
+bool PlaceholderCache::SetSize(const NcaID& id, u64 new_size) const {
+    const auto path = GetRelativePathFromNcaID(id, false, true, false);
+    const auto file = dir->GetFileRelative(path);
+
+    if (file == nullptr)
+        return false;
+
+    return file->Resize(new_size);
+}
+
+std::vector<NcaID> PlaceholderCache::List() const {
+    std::vector<NcaID> out;
+    for (const auto& sdir : dir->GetSubdirectories()) {
+        for (const auto& file : sdir->GetFiles()) {
+            const auto name = file->GetName();
+            if (name.length() == 36 && name[32] == '.' && name[33] == 'n' && name[34] == 'c' &&
+                name[35] == 'a') {
+                out.push_back(Common::HexStringToArray<0x10>(name.substr(0, 32)));
+            }
+        }
+    }
+    return out;
+}
+
+NcaID PlaceholderCache::Generate() {
+    std::random_device device;
+    std::mt19937 gen(device());
+    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
+
+    NcaID out{};
+
+    const auto v1 = distribution(gen);
+    const auto v2 = distribution(gen);
+    std::memcpy(out.data(), &v1, sizeof(u64));
+    std::memcpy(out.data() + sizeof(u64), &v2, sizeof(u64));
+
+    return out;
+}
+
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                        std::string_view path) const {
     const auto file = dir->GetFileRelative(path);
@@ -169,14 +323,18 @@ VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
 
 VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
     VirtualFile file;
-    // Try all four modes of file storage:
-    // (bit 1 = uppercase/lower, bit 0 = within a two-digit dir)
-    // 00: /000000**/{:032X}.nca
-    // 01: /{:032X}.nca
-    // 10: /000000**/{:032x}.nca
-    // 11: /{:032x}.nca
-    for (u8 i = 0; i < 4; ++i) {
-        const auto path = GetRelativePathFromNcaID(id, (i & 0b10) == 0, (i & 0b01) == 0);
+    // Try all five relevant modes of file storage:
+    // (bit 2 = uppercase/lower, bit 1 = within a two-digit dir, bit 0 = .cnmt suffix)
+    // 000: /000000**/{:032X}.nca
+    // 010: /{:032X}.nca
+    // 100: /000000**/{:032x}.nca
+    // 110: /{:032x}.nca
+    // 111: /{:032x}.cnmt.nca
+    for (u8 i = 0; i < 8; ++i) {
+        if ((i % 2) == 1 && i != 7)
+            continue;
+        const auto path =
+            GetRelativePathFromNcaID(id, (i & 0b100) == 0, (i & 0b010) == 0, (i & 0b001) == 0b001);
         file = OpenFileOrDirectoryConcat(dir, path);
         if (file != nullptr)
             return file;
@@ -472,7 +630,7 @@ InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFuncti
         memcpy(id.data(), hash.data(), 16);
     }
 
-    std::string path = GetRelativePathFromNcaID(id, false, true);
+    std::string path = GetRelativePathFromNcaID(id, false, true, false);
 
     if (GetFileAtID(id) != nullptr && !overwrite_if_exists) {
         LOG_WARNING(Loader, "Attempting to overwrite existing NCA. Skipping...");

src/core/file_sys/registered_cache.h

@@ -25,6 +25,8 @@ enum class NCAContentType : u8;
 enum class TitleType : u8;
 
 struct ContentRecord;
+struct MetaRecord;
+class RegisteredCache;
 
 using NcaID = std::array<u8, 0x10>;
 using ContentProviderParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
@@ -89,6 +91,27 @@ protected:
     Core::Crypto::KeyManager keys;
 };
 
+class PlaceholderCache {
+public:
+    explicit PlaceholderCache(VirtualDir dir);
+
+    bool Create(const NcaID& id, u64 size) const;
+    bool Delete(const NcaID& id) const;
+    bool Exists(const NcaID& id) const;
+    bool Write(const NcaID& id, u64 offset, const std::vector<u8>& data) const;
+    bool Register(RegisteredCache* cache, const NcaID& placeholder, const NcaID& install) const;
+    bool CleanAll() const;
+    std::optional<std::array<u8, 0x10>> GetRightsID(const NcaID& id) const;
+    u64 Size(const NcaID& id) const;
+    bool SetSize(const NcaID& id, u64 new_size) const;
+    std::vector<NcaID> List() const;
+
+    static NcaID Generate();
+
+private:
+    VirtualDir dir;
+};
+
 /*
  * A class that catalogues NCAs in the registered directory structure.
  * Nintendo's registered format follows this structure:
@@ -103,6 +126,8 @@ protected:
  * when 4GB splitting can be ignored.)
  */
 class RegisteredCache : public ContentProvider {
+    friend class PlaceholderCache;
+
 public:
     // Parsing function defines the conversion from raw file to NCA. If there are other steps
     // besides creating the NCA from the file (e.g. NAX0 on SD Card), that should go in a custom

src/core/file_sys/romfs_factory.cpp

@@ -7,6 +7,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
+#include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -34,16 +35,17 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
     this->update_raw = std::move(update_raw);
 }
 
-ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
+ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
     if (!updatable)
         return MakeResult<VirtualFile>(file);
 
-    const PatchManager patch_manager(Core::CurrentProcess()->GetTitleID());
+    const PatchManager patch_manager(current_process_title_id);
     return MakeResult<VirtualFile>(
         patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
 
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
+                                          ContentRecordType type) const {
     std::shared_ptr<NCA> res;
 
     switch (storage) {
@@ -51,13 +53,17 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, Conte
         res = Core::System::GetInstance().GetContentProvider().GetEntry(title_id, type);
         break;
     case StorageId::NandSystem:
-        res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);
+        res =
+            Core::System::GetInstance().GetFileSystemController().GetSystemNANDContents()->GetEntry(
+                title_id, type);
         break;
     case StorageId::NandUser:
-        res = Service::FileSystem::GetUserNANDContents()->GetEntry(title_id, type);
+        res = Core::System::GetInstance().GetFileSystemController().GetUserNANDContents()->GetEntry(
+            title_id, type);
         break;
     case StorageId::SdCard:
-        res = Service::FileSystem::GetSDMCContents()->GetEntry(title_id, type);
+        res = Core::System::GetInstance().GetFileSystemController().GetSDMCContents()->GetEntry(
+            title_id, type);
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));

src/core/file_sys/romfs_factory.h

@@ -33,8 +33,8 @@ public:
     ~RomFSFactory();
 
     void SetPackedUpdate(VirtualFile update_raw);
-    ResultVal<VirtualFile> OpenCurrentProcess();
-    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);
+    ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type) const;
 
 private:
     VirtualFile file;

src/core/file_sys/savedata_factory.cpp

@@ -15,22 +15,8 @@ namespace FileSys {
 
 constexpr char SAVE_DATA_SIZE_FILENAME[] = ".yuzu_save_size";
 
-std::string SaveDataDescriptor::DebugInfo() const {
-    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}, "
-                       "rank={}, index={}]",
-                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id,
-                       static_cast<u8>(rank), index);
-}
-
-SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {
-    // Delete all temporary storages
-    // On hardware, it is expected that temporary storage be empty at first use.
-    dir->DeleteSubdirectoryRecursive("temp");
-}
-
-SaveDataFactory::~SaveDataFactory() = default;
-
-ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataDescriptor& meta) {
+namespace {
+void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
     if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
         if (meta.zero_1 != 0) {
             LOG_WARNING(Service_FS,
@@ -65,23 +51,51 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, const SaveDat
                     "non-zero ({:016X}{:016X})",
                     meta.user_id[1], meta.user_id[0]);
     }
+}
+} // Anonymous namespace
 
-    std::string save_directory =
+std::string SaveDataDescriptor::DebugInfo() const {
+    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, "
+                       "save_id={:016X}, "
+                       "rank={}, index={}]",
+                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id,
+                       static_cast<u8>(rank), index);
+}
+
+SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {
+    // Delete all temporary storages
+    // On hardware, it is expected that temporary storage be empty at first use.
+    dir->DeleteSubdirectoryRecursive("temp");
+}
+
+SaveDataFactory::~SaveDataFactory() = default;
+
+ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
+                                              const SaveDataDescriptor& meta) const {
+    PrintSaveDataDescriptorWarnings(meta);
+
+    const auto save_directory =
         GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
-    // TODO(DarkLordZach): Try to not create when opening, there are dedicated create save methods.
-    // But, user_ids don't match so this works for now.
+    auto out = dir->CreateDirectoryRelative(save_directory);
+
+    // Return an error if the save data doesn't actually exist.
+    if (out == nullptr) {
+        // TODO(DarkLordZach): Find out correct error code.
+        return ResultCode(-1);
+    }
+
+    return MakeResult<VirtualDir>(std::move(out));
+}
+
+ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
+                                            const SaveDataDescriptor& meta) const {
+
+    const auto save_directory =
+        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
-    if (out == nullptr) {
-        // TODO(bunnei): This is a work-around to always create a save data directory if it does not
-        // already exist. This is a hack, as we do not understand yet how this works on hardware.
-        // Without a save data directory, many games will assert on boot. This should not have any
-        // bad side-effects.
-        out = dir->CreateDirectoryRelative(save_directory);
-    }
-
     // Return an error if the save data doesn't actually exist.
     if (out == nullptr) {
         // TODO(Subv): Find out correct error code.
@@ -113,8 +127,9 @@ 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::CurrentProcess()->GetTitleID();
+    if (type == SaveDataType::SaveData && title_id == 0) {
+        title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
+    }
 
     std::string out = GetSaveDataSpaceIdPath(space);
 
@@ -152,7 +167,7 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
 }
 
 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
-                                        SaveDataSize new_value) {
+                                        SaveDataSize new_value) const {
     const auto path = GetFullPath(SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
     const auto dir = GetOrCreateDirectoryRelative(this->dir, path);
 

src/core/file_sys/savedata_factory.h

@@ -64,7 +64,8 @@ public:
     explicit SaveDataFactory(VirtualDir dir);
     ~SaveDataFactory();
 
-    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataDescriptor& meta);
+    ResultVal<VirtualDir> Create(SaveDataSpaceId space, const SaveDataDescriptor& meta) const;
+    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataDescriptor& meta) const;
 
     VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
 
@@ -73,7 +74,8 @@ public:
                                    u128 user_id, u64 save_id);
 
     SaveDataSize ReadSaveDataSize(SaveDataType type, u64 title_id, u128 user_id) const;
-    void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id, SaveDataSize new_value);
+    void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
+                           SaveDataSize new_value) const;
 
 private:
     VirtualDir dir;

src/core/file_sys/sdmc_factory.cpp

@@ -6,6 +6,7 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/xts_archive.h"
+#include "core/settings.h"
 
 namespace FileSys {
 
@@ -14,16 +15,38 @@ SDMCFactory::SDMCFactory(VirtualDir dir_)
                                 GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/registered"),
                                 [](const VirtualFile& file, const NcaID& id) {
                                     return NAX{file, id}.GetDecrypted();
-                                })) {}
+                                })),
+      placeholder(std::make_unique<PlaceholderCache>(
+          GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/placehld"))) {}
 
 SDMCFactory::~SDMCFactory() = default;
 
-ResultVal<VirtualDir> SDMCFactory::Open() {
+ResultVal<VirtualDir> SDMCFactory::Open() const {
     return MakeResult<VirtualDir>(dir);
 }
 
+VirtualDir SDMCFactory::GetSDMCContentDirectory() const {
+    return GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents");
+}
+
 RegisteredCache* SDMCFactory::GetSDMCContents() const {
     return contents.get();
 }
 
+PlaceholderCache* SDMCFactory::GetSDMCPlaceholder() const {
+    return placeholder.get();
+}
+
+VirtualDir SDMCFactory::GetImageDirectory() const {
+    return GetOrCreateDirectoryRelative(dir, "/Nintendo/Album");
+}
+
+u64 SDMCFactory::GetSDMCFreeSpace() const {
+    return GetSDMCTotalSpace() - dir->GetSize();
+}
+
+u64 SDMCFactory::GetSDMCTotalSpace() const {
+    return static_cast<u64>(Settings::values.sdmc_size);
+}
+
 } // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -11,6 +11,7 @@
 namespace FileSys {
 
 class RegisteredCache;
+class PlaceholderCache;
 
 /// File system interface to the SDCard archive
 class SDMCFactory {
@@ -18,13 +19,23 @@ public:
     explicit SDMCFactory(VirtualDir dir);
     ~SDMCFactory();
 
-    ResultVal<VirtualDir> Open();
+    ResultVal<VirtualDir> Open() const;
+
+    VirtualDir GetSDMCContentDirectory() const;
+
     RegisteredCache* GetSDMCContents() const;
+    PlaceholderCache* GetSDMCPlaceholder() const;
+
+    VirtualDir GetImageDirectory() const;
+
+    u64 GetSDMCFreeSpace() const;
+    u64 GetSDMCTotalSpace() const;
 
 private:
     VirtualDir dir;
 
     std::unique_ptr<RegisteredCache> contents;
+    std::unique_ptr<PlaceholderCache> placeholder;
 };
 
 } // namespace FileSys

src/core/file_sys/submission_package.cpp

@@ -14,6 +14,7 @@
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
+#include "core/file_sys/program_metadata.h"
 #include "core/file_sys/submission_package.h"
 #include "core/loader/loader.h"
 
@@ -78,6 +79,10 @@ Loader::ResultStatus NSP::GetStatus() const {
 }
 
 Loader::ResultStatus NSP::GetProgramStatus(u64 title_id) const {
+    if (IsExtractedType() && GetExeFS() != nullptr && FileSys::IsDirectoryExeFS(GetExeFS())) {
+        return Loader::ResultStatus::Success;
+    }
+
     const auto iter = program_status.find(title_id);
     if (iter == program_status.end())
         return Loader::ResultStatus::ErrorNSPMissingProgramNCA;
@@ -85,12 +90,29 @@ Loader::ResultStatus NSP::GetProgramStatus(u64 title_id) const {
 }
 
 u64 NSP::GetFirstTitleID() const {
+    if (IsExtractedType()) {
+        return GetProgramTitleID();
+    }
+
     if (program_status.empty())
         return 0;
     return program_status.begin()->first;
 }
 
 u64 NSP::GetProgramTitleID() const {
+    if (IsExtractedType()) {
+        if (GetExeFS() == nullptr || !IsDirectoryExeFS(GetExeFS())) {
+            return 0;
+        }
+
+        ProgramMetadata meta;
+        if (meta.Load(GetExeFS()->GetFile("main.npdm")) == Loader::ResultStatus::Success) {
+            return meta.GetTitleID();
+        } else {
+            return 0;
+        }
+    }
+
     const auto out = GetFirstTitleID();
     if ((out & 0x800) == 0)
         return out;
@@ -102,6 +124,10 @@ u64 NSP::GetProgramTitleID() const {
 }
 
 std::vector<u64> NSP::GetTitleIDs() const {
+    if (IsExtractedType()) {
+        return {GetProgramTitleID()};
+    }
+
     std::vector<u64> out;
     out.reserve(ncas.size());
     for (const auto& kv : ncas)
@@ -222,7 +248,8 @@ void NSP::InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files) {
 
 void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
     for (const auto& outer_file : files) {
-        if (outer_file->GetName().substr(outer_file->GetName().size() - 9) != ".cnmt.nca") {
+        if (outer_file->GetName().size() < 9 ||
+            outer_file->GetName().substr(outer_file->GetName().size() - 9) != ".cnmt.nca") {
             continue;
         }
 

src/core/file_sys/system_archive/mii_model.cpp

@@ -0,0 +1,46 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/file_sys/system_archive/mii_model.h"
+#include "core/file_sys/vfs_vector.h"
+
+namespace FileSys::SystemArchive {
+
+namespace MiiModelData {
+
+constexpr std::array<u8, 0x10> NFTR_STANDARD{'N',  'F',  'T',  'R',  0x01, 0x00, 0x00, 0x00,
+                                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+constexpr std::array<u8, 0x10> NFSR_STANDARD{'N',  'F',  'S',  'R',  0x01, 0x00, 0x00, 0x00,
+                                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+constexpr auto TEXTURE_LOW_LINEAR = NFTR_STANDARD;
+constexpr auto TEXTURE_LOW_SRGB = NFTR_STANDARD;
+constexpr auto TEXTURE_MID_LINEAR = NFTR_STANDARD;
+constexpr auto TEXTURE_MID_SRGB = NFTR_STANDARD;
+constexpr auto SHAPE_HIGH = NFSR_STANDARD;
+constexpr auto SHAPE_MID = NFSR_STANDARD;
+
+} // namespace MiiModelData
+
+VirtualDir MiiModel() {
+    auto out = std::make_shared<VectorVfsDirectory>(std::vector<VirtualFile>{},
+                                                    std::vector<VirtualDir>{}, "data");
+
+    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_LOW_LINEAR.size()>>(
+        MiiModelData::TEXTURE_LOW_LINEAR, "NXTextureLowLinear.dat"));
+    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_LOW_SRGB.size()>>(
+        MiiModelData::TEXTURE_LOW_SRGB, "NXTextureLowSRGB.dat"));
+    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_MID_LINEAR.size()>>(
+        MiiModelData::TEXTURE_MID_LINEAR, "NXTextureMidLinear.dat"));
+    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_MID_SRGB.size()>>(
+        MiiModelData::TEXTURE_MID_SRGB, "NXTextureMidSRGB.dat"));
+    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::SHAPE_HIGH.size()>>(
+        MiiModelData::SHAPE_HIGH, "ShapeHigh.dat"));
+    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::SHAPE_MID.size()>>(
+        MiiModelData::SHAPE_MID, "ShapeMid.dat"));
+
+    return std::move(out);
+}
+
+} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/mii_model.h

@@ -0,0 +1,13 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/file_sys/vfs_types.h"
+
+namespace FileSys::SystemArchive {
+
+VirtualDir MiiModel();
+
+} // namespace FileSys::SystemArchive

src/core/file_sys/system_archive/system_archive.cpp

@@ -4,6 +4,7 @@
 
 #include "common/logging/log.h"
 #include "core/file_sys/romfs.h"
+#include "core/file_sys/system_archive/mii_model.h"
 #include "core/file_sys/system_archive/ng_word.h"
 #include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/system_archive/system_version.h"
@@ -24,7 +25,7 @@ struct SystemArchiveDescriptor {
 constexpr std::array<SystemArchiveDescriptor, SYSTEM_ARCHIVE_COUNT> SYSTEM_ARCHIVES{{
     {0x0100000000000800, "CertStore", nullptr},
     {0x0100000000000801, "ErrorMessage", nullptr},
-    {0x0100000000000802, "MiiModel", nullptr},
+    {0x0100000000000802, "MiiModel", &MiiModel},
     {0x0100000000000803, "BrowserDll", nullptr},
     {0x0100000000000804, "Help", nullptr},
     {0x0100000000000805, "SharedFont", nullptr},

src/core/file_sys/vfs_libzip.cpp

@@ -0,0 +1,79 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <string>
+#include <zip.h>
+#include "common/logging/backend.h"
+#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_libzip.h"
+#include "core/file_sys/vfs_vector.h"
+
+namespace FileSys {
+
+VirtualDir ExtractZIP(VirtualFile file) {
+    zip_error_t error{};
+
+    const auto data = file->ReadAllBytes();
+    std::unique_ptr<zip_source_t, decltype(&zip_source_close)> src{
+        zip_source_buffer_create(data.data(), data.size(), 0, &error), zip_source_close};
+    if (src == nullptr)
+        return nullptr;
+
+    std::unique_ptr<zip_t, decltype(&zip_close)> zip{zip_open_from_source(src.get(), 0, &error),
+                                                     zip_close};
+    if (zip == nullptr)
+        return nullptr;
+
+    std::shared_ptr<VectorVfsDirectory> out = std::make_shared<VectorVfsDirectory>();
+
+    const auto num_entries = zip_get_num_entries(zip.get(), 0);
+
+    zip_stat_t stat{};
+    zip_stat_init(&stat);
+
+    for (std::size_t i = 0; i < num_entries; ++i) {
+        const auto stat_res = zip_stat_index(zip.get(), i, 0, &stat);
+        if (stat_res == -1)
+            return nullptr;
+
+        const std::string name(stat.name);
+        if (name.empty())
+            continue;
+
+        if (name.back() != '/') {
+            std::unique_ptr<zip_file_t, decltype(&zip_fclose)> file{
+                zip_fopen_index(zip.get(), i, 0), zip_fclose};
+
+            std::vector<u8> buf(stat.size);
+            if (zip_fread(file.get(), buf.data(), buf.size()) != buf.size())
+                return nullptr;
+
+            const auto parts = FileUtil::SplitPathComponents(stat.name);
+            const auto new_file = std::make_shared<VectorVfsFile>(buf, parts.back());
+
+            std::shared_ptr<VectorVfsDirectory> dtrv = out;
+            for (std::size_t j = 0; j < parts.size() - 1; ++j) {
+                if (dtrv == nullptr)
+                    return nullptr;
+                const auto subdir = dtrv->GetSubdirectory(parts[j]);
+                if (subdir == nullptr) {
+                    const auto temp = std::make_shared<VectorVfsDirectory>(
+                        std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, parts[j]);
+                    dtrv->AddDirectory(temp);
+                    dtrv = temp;
+                } else {
+                    dtrv = std::dynamic_pointer_cast<VectorVfsDirectory>(subdir);
+                }
+            }
+
+            if (dtrv == nullptr)
+                return nullptr;
+            dtrv->AddFile(new_file);
+        }
+    }
+
+    return out;
+}
+
+} // namespace FileSys

src/core/file_sys/vfs_libzip.h

@@ -0,0 +1,13 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/file_sys/vfs_types.h"
+
+namespace FileSys {
+
+VirtualDir ExtractZIP(VirtualFile zip);
+
+} // namespace FileSys

src/core/gdbstub/gdbstub.cpp

@@ -202,13 +202,11 @@ void RegisterModule(std::string name, VAddr beg, VAddr end, bool add_elf_ext) {
 }
 
 static Kernel::Thread* FindThreadById(s64 id) {
-    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();
-            }
+    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();
         }
     }
     return nullptr;
@@ -641,16 +639,15 @@ 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::CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
+        const VAddr base_address =
+            Core::System::GetInstance().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";
-        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());
-            }
+        const auto& threads = Core::System::GetInstance().GlobalScheduler().GetThreadList();
+        for (const auto& thread : threads) {
+            val += fmt::format("{:x},", thread->GetThreadID());
         }
         val.pop_back();
         SendReply(val.c_str());
@@ -660,13 +657,11 @@ static void HandleQuery() {
         std::string buffer;
         buffer += "l<?xml version=\"1.0\"?>";
         buffer += "<threads>";
-        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());
-            }
+        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());
         }
         buffer += "</threads>";
         SendReply(buffer.c_str());

src/core/hle/kernel/address_arbiter.cpp

@@ -22,6 +22,7 @@ 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();
@@ -35,6 +36,7 @@ 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
@@ -169,30 +171,22 @@ ResultCode AddressArbiter::WaitForAddressImpl(VAddr address, s64 timeout) {
 
     current_thread->WakeAfterDelay(timeout);
 
-    system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
+    system.PrepareReschedule(current_thread->GetProcessorID());
     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;
-    RetrieveWaitingThreads(0, threads, address);
-    RetrieveWaitingThreads(1, threads, address);
-    RetrieveWaitingThreads(2, threads, address);
-    RetrieveWaitingThreads(3, threads, address);
+    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);
+        }
+    }
 
     // Sort them by priority, such that the highest priority ones come first.
     std::sort(threads.begin(), threads.end(),

src/core/hle/kernel/handle_table.cpp

@@ -103,7 +103,7 @@ SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
     if (handle == CurrentThread) {
         return GetCurrentThread();
     } else if (handle == CurrentProcess) {
-        return Core::CurrentProcess();
+        return Core::System::GetInstance().CurrentProcess();
     }
 
     if (!IsValid(handle)) {

src/core/hle/kernel/kernel.cpp

@@ -18,6 +18,7 @@
 #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"
@@ -88,7 +89,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
 }
 
 struct KernelCore::Impl {
-    explicit Impl(Core::System& system) : system{system} {}
+    explicit Impl(Core::System& system) : system{system}, global_scheduler{system} {}
 
     void Initialize(KernelCore& kernel) {
         Shutdown();
@@ -140,6 +141,7 @@ 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;
 
@@ -203,6 +205,14 @@ 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));
 }

src/core/hle/kernel/kernel.h

@@ -25,6 +25,7 @@ class HandleTable;
 class Process;
 class ResourceLimit;
 class Thread;
+class GlobalScheduler;
 
 /// Represents a single instance of the kernel.
 class KernelCore {
@@ -75,6 +76,12 @@ 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);
 

src/core/hle/kernel/mutex.cpp

@@ -7,6 +7,7 @@
 
 #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"
@@ -78,7 +79,7 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
     // thread.
     ASSERT(requesting_thread == current_thread);
 
-    const u32 addr_value = Memory::Read32(address);
+    u32 addr_value = Memory::Read32(address);
 
     // If the mutex isn't being held, just return success.
     if (addr_value != (holding_thread_handle | Mutex::MutexHasWaitersFlag)) {
@@ -89,6 +90,20 @@ 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);
@@ -104,14 +119,13 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
     return RESULT_SUCCESS;
 }
 
-ResultCode Mutex::Release(VAddr address) {
+ResultCode Mutex::Release(VAddr address, Thread* holding_thread) {
     // The mutex address must be 4-byte aligned
     if ((address % sizeof(u32)) != 0) {
         return ERR_INVALID_ADDRESS;
     }
 
-    auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
-    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(current_thread, address);
+    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(holding_thread, address);
 
     // There are no more threads waiting for the mutex, release it completely.
     if (thread == nullptr) {
@@ -120,7 +134,7 @@ ResultCode Mutex::Release(VAddr address) {
     }
 
     // Transfer the ownership of the mutex from the previous owner to the new one.
-    TransferMutexOwnership(address, current_thread, thread);
+    TransferMutexOwnership(address, holding_thread, thread);
 
     u32 mutex_value = thread->GetWaitHandle();
 
@@ -140,6 +154,11 @@ ResultCode Mutex::Release(VAddr address) {
     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

src/core/hle/kernel/mutex.h

@@ -29,7 +29,7 @@ public:
                           Handle requesting_thread_handle);
 
     /// Releases the mutex at the specified address.
-    ResultCode Release(VAddr address);
+    ResultCode Release(VAddr address, Thread* holding_thread);
 
 private:
     Core::System& system;

src/core/hle/kernel/process.cpp

@@ -213,10 +213,7 @@ void Process::PrepareForTermination() {
         }
     };
 
-    stop_threads(system.Scheduler(0).GetThreadList());
-    stop_threads(system.Scheduler(1).GetThreadList());
-    stop_threads(system.Scheduler(2).GetThreadList());
-    stop_threads(system.Scheduler(3).GetThreadList());
+    stop_threads(system.GlobalScheduler().GetThreadList());
 
     FreeTLSRegion(tls_region_address);
     tls_region_address = 0;

src/core/hle/kernel/scheduler.cpp

@@ -1,8 +1,13 @@
 // 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"
@@ -17,56 +22,277 @@
 
 namespace Kernel {
 
-std::mutex Scheduler::scheduler_mutex;
+GlobalScheduler::GlobalScheduler(Core::System& system) : system{system} {
+    reselection_pending = false;
+}
 
-Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core)
-    : cpu_core{cpu_core}, system{system} {}
+void GlobalScheduler::AddThread(SharedPtr<Thread> thread) {
+    thread_list.push_back(std::move(thread));
+}
 
-Scheduler::~Scheduler() {
-    for (auto& thread : thread_list) {
-        thread->Stop();
+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);
     }
 }
 
+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 {
-    std::lock_guard lock{scheduler_mutex};
-    return !ready_queue.empty();
+    return system.GlobalScheduler().HaveReadyThreads(core_id);
 }
 
 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;
 }
 
-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();
+void Scheduler::TryDoContextSwitch() {
+    if (context_switch_pending) {
+        SwitchContext();
     }
-
-    return next;
 }
 
-void Scheduler::SwitchContext(Thread* new_thread) {
-    Thread* previous_thread = GetCurrentThread();
+void Scheduler::UnloadThread() {
+    Thread* const previous_thread = GetCurrentThread();
     Process* const previous_process = system.Kernel().CurrentProcess();
 
     UpdateLastContextSwitchTime(previous_thread, previous_process);
@@ -80,23 +306,52 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         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) {
@@ -130,124 +385,4 @@ 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

src/core/hle/kernel/scheduler.h

@@ -20,124 +20,178 @@ namespace Kernel {
 
 class Process;
 
-class Scheduler final {
+class GlobalScheduler final {
 public:
-    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 Reschedule();
-
-    /// Gets the current running thread
-    Thread* GetCurrentThread() const;
-
-    /// Gets the timestamp for the last context switch in ticks.
-    u64 GetLastContextSwitchTicks() const;
+    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(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);
+    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;
     }
 
-private:
-    /**
-     * Pops and returns the next thread from the thread queue
-     * @return A pointer to the next ready thread
-     */
-    Thread* PopNextReadyThread();
+    // 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);
+    ~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();
+
+    /// 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;
+    }
+
+private:
+    friend class GlobalScheduler;
     /**
      * Switches the CPU's active thread context to that of the specified thread
      * @param new_thread The thread to switch to
      */
-    void SwitchContext(Thread* new_thread);
+    void SwitchContext();
 
     /**
      * Called on every context switch to update the internal timestamp
@@ -152,19 +206,16 @@ 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;
-
-    Core::ARM_Interface& cpu_core;
-    u64 last_context_switch_time = 0;
+    SharedPtr<Thread> selected_thread = nullptr;
 
     Core::System& system;
-    static std::mutex scheduler_mutex;
+    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;
 };
 
 } // namespace Kernel

src/core/hle/kernel/svc.cpp

@@ -516,7 +516,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
     thread->WakeAfterDelay(nano_seconds);
     thread->SetWakeupCallback(DefaultThreadWakeupCallback);
 
-    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
+    system.PrepareReschedule(thread->GetProcessorID());
 
     return RESULT_TIMEOUT;
 }
@@ -534,6 +534,7 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
     }
 
     thread->CancelWait();
+    system.PrepareReschedule(thread->GetProcessorID());
     return RESULT_SUCCESS;
 }
 
@@ -577,7 +578,8 @@ static ResultCode ArbitrateUnlock(Core::System& system, VAddr mutex_addr) {
     }
 
     auto* const current_process = system.Kernel().CurrentProcess();
-    return current_process->GetMutex().Release(mutex_addr);
+    return current_process->GetMutex().Release(mutex_addr,
+                                               system.CurrentScheduler().GetCurrentThread());
 }
 
 enum class BreakType : u32 {
@@ -1066,6 +1068,8 @@ static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 act
     }
 
     thread->SetActivity(static_cast<ThreadActivity>(activity));
+
+    system.PrepareReschedule(thread->GetProcessorID());
     return RESULT_SUCCESS;
 }
 
@@ -1147,7 +1151,7 @@ static ResultCode SetThreadPriority(Core::System& system, Handle handle, u32 pri
 
     thread->SetPriority(priority);
 
-    system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
+    system.PrepareReschedule(thread->GetProcessorID());
     return RESULT_SUCCESS;
 }
 
@@ -1503,7 +1507,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.CpuCore(thread->GetProcessorID()).PrepareReschedule();
+    system.PrepareReschedule(thread->GetProcessorID());
 
     return RESULT_SUCCESS;
 }
@@ -1525,7 +1529,7 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
     thread->ResumeFromWait();
 
     if (thread->GetStatus() == ThreadStatus::Ready) {
-        system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
+        system.PrepareReschedule(thread->GetProcessorID());
     }
 
     return RESULT_SUCCESS;
@@ -1537,7 +1541,7 @@ static void ExitThread(Core::System& system) {
 
     auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
     current_thread->Stop();
-    system.CurrentScheduler().RemoveThread(current_thread);
+    system.GlobalScheduler().RemoveThread(current_thread);
     system.PrepareReschedule();
 }
 
@@ -1557,13 +1561,13 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
     if (nanoseconds <= 0) {
         switch (static_cast<SleepType>(nanoseconds)) {
         case SleepType::YieldWithoutLoadBalancing:
-            scheduler.YieldWithoutLoadBalancing(current_thread);
+            current_thread->YieldSimple();
             break;
         case SleepType::YieldWithLoadBalancing:
-            scheduler.YieldWithLoadBalancing(current_thread);
+            current_thread->YieldAndBalanceLoad();
             break;
         case SleepType::YieldAndWaitForLoadBalancing:
-            scheduler.YieldAndWaitForLoadBalancing(current_thread);
+            current_thread->YieldAndWaitForLoadBalancing();
             break;
         default:
             UNREACHABLE_MSG("Unimplemented sleep yield type '{:016X}'!", nanoseconds);
@@ -1572,10 +1576,7 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
         current_thread->Sleep(nanoseconds);
     }
 
-    // Reschedule all CPU cores
-    for (std::size_t i = 0; i < Core::NUM_CPU_CORES; ++i) {
-        system.CpuCore(i).PrepareReschedule();
-    }
+    system.PrepareReschedule(current_thread->GetProcessorID());
 }
 
 /// Wait process wide key atomic
@@ -1606,12 +1607,14 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
     SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     ASSERT(thread);
 
-    const auto release_result = current_process->GetMutex().Release(mutex_addr);
+    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
+
+    const auto release_result =
+        current_process->GetMutex().Release(mutex_addr, current_thread.get());
     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);
@@ -1622,7 +1625,7 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
 
     // Note: Deliberately don't attempt to inherit the lock owner's priority.
 
-    system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
+    system.PrepareReschedule(current_thread->GetProcessorID());
     return RESULT_SUCCESS;
 }
 
@@ -1632,24 +1635,17 @@ 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;
-    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);
+    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);
+        }
+    }
+
     // 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) {
@@ -1704,7 +1700,7 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
             thread->SetLockOwner(nullptr);
             thread->SetMutexWaitAddress(0);
             thread->SetWaitHandle(0);
-            system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
+            system.PrepareReschedule(thread->GetProcessorID());
         } else {
             // Atomically signal that the mutex now has a waiting thread.
             do {
@@ -1728,6 +1724,7 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
             thread->SetStatus(ThreadStatus::WaitMutex);
 
             owner->AddMutexWaiter(thread);
+            system.PrepareReschedule(thread->GetProcessorID());
         }
     }
 
@@ -1754,7 +1751,12 @@ 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();
-    return address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
+    const ResultCode result =
+        address_arbiter.WaitForAddress(address, arbitration_type, value, timeout);
+    if (result == RESULT_SUCCESS) {
+        system.PrepareReschedule();
+    }
+    return result;
 }
 
 // Signals to an address (via Address Arbiter)
@@ -2040,7 +2042,10 @@ 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;
 }
 
@@ -2151,6 +2156,7 @@ static ResultCode SignalEvent(Core::System& system, Handle handle) {
     }
 
     writable_event->Signal();
+    system.PrepareReschedule();
     return RESULT_SUCCESS;
 }
 

src/core/hle/kernel/thread.cpp

@@ -45,15 +45,7 @@ void Thread::Stop() {
                                                              callback_handle);
     kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
     callback_handle = 0;
-
-    // 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;
-
+    SetStatus(ThreadStatus::Dead);
     WakeupAllWaitingThreads();
 
     // Clean up any dangling references in objects that this thread was waiting for
@@ -132,13 +124,11 @@ void Thread::ResumeFromWait() {
     wakeup_callback = nullptr;
 
     if (activity == ThreadActivity::Paused) {
-        status = ThreadStatus::Paused;
+        SetStatus(ThreadStatus::Paused);
         return;
     }
 
-    status = ThreadStatus::Ready;
-
-    ChangeScheduler();
+    SetStatus(ThreadStatus::Ready);
 }
 
 void Thread::CancelWait() {
@@ -205,9 +195,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());
 
@@ -250,6 +240,22 @@ 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();
     }
@@ -311,8 +317,7 @@ void Thread::UpdatePriority() {
         return;
     }
 
-    scheduler->SetThreadPriority(this, new_priority);
-    current_priority = new_priority;
+    SetCurrentPriority(new_priority);
 
     if (!lock_owner) {
         return;
@@ -328,47 +333,7 @@ void Thread::UpdatePriority() {
 }
 
 void Thread::ChangeCore(u32 core, u64 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();
+    SetCoreAndAffinityMask(core, mask);
 }
 
 bool Thread::AllWaitObjectsReady() const {
@@ -391,7 +356,7 @@ void Thread::SetActivity(ThreadActivity value) {
         if (status == ThreadStatus::Ready) {
             status = ThreadStatus::Paused;
         } else if (status == ThreadStatus::Running) {
-            status = ThreadStatus::Paused;
+            SetStatus(ThreadStatus::Paused);
             Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
         }
     } else if (status == ThreadStatus::Paused) {
@@ -408,6 +373,171 @@ 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();
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**

src/core/hle/kernel/thread.h

@@ -75,6 +75,26 @@ 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>>;
@@ -278,6 +298,10 @@ public:
         return processor_id;
     }
 
+    void SetProcessorID(s32 new_core) {
+        processor_id = new_core;
+    }
+
     Process* GetOwnerProcess() {
         return owner_process;
     }
@@ -383,11 +407,38 @@ 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 ChangeScheduler();
+    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);
 
     Core::ARM_Interface::ThreadContext context{};
 
@@ -453,6 +504,13 @@ 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;
 };