mii: Handle logging of unknown database source

.ci/scripts/common/post-upload.sh

@@ -1,15 +0,0 @@
-#!/bin/bash -ex
-
-# Copy documentation
-cp license.txt "$REV_NAME"
-cp README.md "$REV_NAME"
-
-tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$REV_NAME"
-
-mv "$REV_NAME" $RELEASE_NAME
-
-7z a "$REV_NAME.7z" $RELEASE_NAME
-
-# move the compiled archive into the artifacts directory to be uploaded by travis releases
-mv "$ARCHIVE_NAME" artifacts/
-mv "$REV_NAME.7z" artifacts/

.ci/scripts/common/pre-upload.sh

@@ -1,6 +0,0 @@
-#!/bin/bash -ex
-
-GITDATE="`git show -s --date=short --format='%ad' | sed 's/-//g'`"
-GITREV="`git show -s --format='%h'`"
-
-mkdir -p artifacts

.ci/scripts/format/docker.sh

@@ -1,6 +0,0 @@
-#!/bin/bash -ex
-
-# Run clang-format
-cd /yuzu
-chmod a+x ./.ci/scripts/format/script.sh
-./.ci/scripts/format/script.sh

.ci/scripts/format/exec.sh

@@ -1,4 +0,0 @@
-#!/bin/bash -ex
-
-chmod a+x ./.ci/scripts/format/docker.sh
-docker run -v $(pwd):/yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh

.ci/scripts/format/script.sh

@@ -1,37 +0,0 @@
-#!/bin/bash -ex
-
-if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* dist/*.desktop \
-                 dist/*.svg dist/*.xml; then
-    echo Trailing whitespace found, aborting
-    exit 1
-fi
-
-# Default clang-format points to default 3.5 version one
-CLANG_FORMAT=clang-format-6.0
-$CLANG_FORMAT --version
-
-if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then
-    # Get list of every file modified in this pull request
-    files_to_lint="$(git diff --name-only --diff-filter=ACMRTUXB $TRAVIS_COMMIT_RANGE | grep '^src/[^.]*[.]\(cpp\|h\)$' || true)"
-else
-    # Check everything for branch pushes
-    files_to_lint="$(find src/ -name '*.cpp' -or -name '*.h')"
-fi
-
-# Turn off tracing for this because it's too verbose
-set +x
-
-for f in $files_to_lint; do
-    d=$(diff -u "$f" <($CLANG_FORMAT "$f") || true)
-    if ! [ -z "$d" ]; then
-        echo "!!! $f not compliant to coding style, here is the fix:"
-        echo "$d"
-        fail=1
-    fi
-done
-
-set -x
-
-if [ "$fail" = 1 ]; then
-    exit 1
-fi

.ci/scripts/linux/docker.sh

@@ -1,14 +0,0 @@
-#!/bin/bash -ex
-
-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
-
-ninja
-
-ccache -s
-
-ctest -VV -C Release

.ci/scripts/linux/exec.sh

@@ -1,5 +0,0 @@
-#!/bin/bash -ex
-
-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

.ci/scripts/linux/upload.sh

@@ -1,14 +0,0 @@
-#!/bin/bash -ex
-
-. .ci/scripts/common/pre-upload.sh
-
-REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
-ARCHIVE_NAME="${REV_NAME}.tar.xz"
-COMPRESSION_FLAGS="-cJvf"
-
-mkdir "$REV_NAME"
-
-cp build/bin/yuzu-cmd "$REV_NAME"
-cp build/bin/yuzu "$REV_NAME"
-
-. .ci/scripts/common/post-upload.sh

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

@@ -1,28 +0,0 @@
-# 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
-
-http = urllib3.PoolManager()
-dl_list = {}
-
-def check_individual(labels):
-    for label in labels:
-        if (label["name"] == sys.argv[1]):
-            return True
-    return False
-
-try:
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls'
-    response = requests.get(url)
-    if (response.ok):
-        j = json.loads(response.content)
-        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]))
-except:
-    sys.exit(-1)

.ci/scripts/merge/check-label-presence.py

@@ -1,18 +0,0 @@
-# Checks to see if the specified pull request # has the specified tag
-# Usage: python check-label-presence.py <Pull Request ID> <Name of Label>
-
-import requests, json, sys
-
-try:
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/issues/%s' % sys.argv[1]
-    response = requests.get(url)
-    if (response.ok):
-        j = json.loads(response.content)
-        for label in j["labels"]:
-            if label["name"] == sys.argv[2]:
-                print('##vso[task.setvariable variable=enabletesting;]true')
-                sys.exit()
-except:
-    sys.exit(-1)
-
-print('##vso[task.setvariable variable=enabletesting;]false')

.ci/scripts/merge/yuzubot-git-config.sh

@@ -1,2 +0,0 @@
-git config --global user.email "yuzu@yuzu-emu.org"
-git config --global user.name "yuzubot"

.ci/scripts/windows/docker.sh

@@ -1,50 +0,0 @@
-#!/bin/bash -ex
-
-cd /yuzu
-
-ccache -s
-
-# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
-mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
-chmod +x /bin/uname
-
-# Dirty hack to trick unicorn makefile into believing we have cmd
-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
-ninja
-
-# Clean up the dirty hacks
-rm /bin/uname && mv /bin/uname1 /bin/uname
-rm /bin/cmd
-
-ccache -s
-
-echo "Tests skipped"
-#ctest -VV -C Release
-
-echo 'Prepare binaries...'
-cd ..
-mkdir package
-
-QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
-find build/ -name "yuzu*.exe" -exec cp {} 'package' \;
-
-# copy Qt plugins
-mkdir package/platforms
-cp "${QT_PLATFORM_DLL_PATH}/qwindows.dll" package/platforms/
-cp -rv "${QT_PLATFORM_DLL_PATH}/../mediaservice/" package/
-cp -rv "${QT_PLATFORM_DLL_PATH}/../imageformats/" package/
-rm -f package/mediaservice/*d.dll
-
-for i in package/*.exe; do
-  # we need to process pdb here, however, cv2pdb
-  # does not work here, so we just simply strip all the debug symbols
-  x86_64-w64-mingw32-strip "${i}"
-done
-
-pip3 install pefile
-python3 .ci/scripts/windows/scan_dll.py package/*.exe "package/"
-python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"

.ci/scripts/windows/exec.sh

@@ -1,5 +0,0 @@
-#!/bin/bash -ex
-
-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

.ci/scripts/windows/scan_dll.py

@@ -1,106 +0,0 @@
-import pefile
-import sys
-import re
-import os
-import queue
-import shutil
-
-# constant definitions
-KNOWN_SYS_DLLS = ['WINMM.DLL', 'MSVCRT.DLL', 'VERSION.DLL', 'MPR.DLL',
-                  'DWMAPI.DLL', 'UXTHEME.DLL', 'DNSAPI.DLL', 'IPHLPAPI.DLL']
-# below is for Ubuntu 18.04 with specified PPA enabled, if you are using
-# other distro or different repositories, change the following accordingly
-DLL_PATH = [
-    '/usr/x86_64-w64-mingw32/bin/',
-    '/usr/x86_64-w64-mingw32/lib/',
-    '/usr/lib/gcc/x86_64-w64-mingw32/7.3-posix/'
-]
-
-missing = []
-
-
-def parse_imports(file_name):
-    results = []
-    pe = pefile.PE(file_name, fast_load=True)
-    pe.parse_data_directories()
-
-    for entry in pe.DIRECTORY_ENTRY_IMPORT:
-        current = entry.dll.decode()
-        current_u = current.upper()  # b/c Windows is often case insensitive
-        # here we filter out system dlls
-        # dll w/ names like *32.dll are likely to be system dlls
-        if current_u.upper() not in KNOWN_SYS_DLLS and not re.match(string=current_u, pattern=r'.*32\.DLL'):
-            results.append(current)
-
-    return results
-
-
-def parse_imports_recursive(file_name, path_list=[]):
-    q = queue.Queue()  # create a FIFO queue
-    # file_name can be a string or a list for the convience
-    if isinstance(file_name, str):
-        q.put(file_name)
-    elif isinstance(file_name, list):
-        for i in file_name:
-            q.put(i)
-    full_list = []
-    while q.qsize():
-        current = q.get_nowait()
-        print('> %s' % current)
-        deps = parse_imports(current)
-        # if this dll does not have any import, ignore it
-        if not deps:
-            continue
-        for dep in deps:
-            # the dependency already included in the list, skip
-            if dep in full_list:
-                continue
-            # find the requested dll in the provided paths
-            full_path = find_dll(dep)
-            if not full_path:
-                missing.append(dep)
-                continue
-            full_list.append(dep)
-            q.put(full_path)
-            path_list.append(full_path)
-    return full_list
-
-
-def find_dll(name):
-    for path in DLL_PATH:
-        for root, _, files in os.walk(path):
-            for f in files:
-                if name.lower() == f.lower():
-                    return os.path.join(root, f)
-
-
-def deploy(name, dst, dry_run=False):
-    dlls_path = []
-    parse_imports_recursive(name, dlls_path)
-    for dll_entry in dlls_path:
-        if not dry_run:
-            shutil.copy(dll_entry, dst)
-        else:
-            print('[Dry-Run] Copy %s to %s' % (dll_entry, dst))
-    print('Deploy completed.')
-    return dlls_path
-
-
-def main():
-    if len(sys.argv) < 3:
-        print('Usage: %s [files to examine ...] [target deploy directory]')
-        return 1
-    to_deploy = sys.argv[1:-1]
-    tgt_dir = sys.argv[-1]
-    if not os.path.isdir(tgt_dir):
-        print('%s is not a directory.' % tgt_dir)
-        return 1
-    print('Scanning dependencies...')
-    deploy(to_deploy, tgt_dir)
-    if missing:
-        print('Following DLLs are not found: %s' % ('\n'.join(missing)))
-    return 0
-
-
-if __name__ == '__main__':
-    main()

.ci/scripts/windows/upload.sh

@@ -1,13 +0,0 @@
-#!/bin/bash -ex
-
-. .ci/scripts/common/pre-upload.sh
-
-REV_NAME="yuzu-windows-mingw-${GITDATE}-${GITREV}"
-ARCHIVE_NAME="${REV_NAME}.tar.gz"
-COMPRESSION_FLAGS="-czvf"
-
-mkdir "$REV_NAME"
-# get around the permission issues
-cp -r package/* "$REV_NAME"
-
-. .ci/scripts/common/post-upload.sh

.ci/templates/build-single.yml

@@ -1,23 +0,0 @@
-parameters:
-  artifactSource: 'true'
-  cache: 'false'
-
-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
-  displayName: 'Build'
-- script: chmod a+x ./.ci/scripts/$(ScriptFolder)/upload.sh && RELEASE_NAME=$(BuildName) ./.ci/scripts/$(ScriptFolder)/upload.sh
-  displayName: 'Package Artifacts'
-- publish: artifacts
-  artifact: 'yuzu-$(BuildName)-$(BuildSuffix)'
-  displayName: 'Upload Artifacts'

.ci/templates/build-standard.yml

@@ -1,23 +0,0 @@
-jobs:
-- job: build
-  displayName: 'standard'
-  pool:
-    vmImage: ubuntu-latest
-  strategy:
-    maxParallel: 10
-    matrix:
-      windows:
-        BuildSuffix: 'windows-mingw'
-        ScriptFolder: 'windows'
-      linux:
-        BuildSuffix: 'linux'
-        ScriptFolder: 'linux'
-  steps:
-  - template: ./sync-source.yml
-    parameters:
-      artifactSource: $(parameters.artifactSource)
-      needSubmodules: 'true'
-  - template: ./build-single.yml
-    parameters:
-      artifactSource: 'false'
-      cache: $(parameters.cache)

.ci/templates/build-testing.yml

@@ -1,33 +0,0 @@
-jobs:
-- job: build_test
-  displayName: 'testing'
-  pool:
-    vmImage: ubuntu-latest
-  strategy:
-    maxParallel: 5
-    matrix:
-      windows:
-        BuildSuffix: 'windows-testing'
-        ScriptFolder: 'windows'
-  steps:
-  - script: sudo apt upgrade python3-pip && pip install requests urllib3
-    displayName: 'Prepare Environment'
-  - task: PythonScript@0
-    condition: eq(variables['Build.Reason'], 'PullRequest')
-    displayName: 'Determine Testing Status'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '.ci/scripts/merge/check-label-presence.py'
-      arguments: '$(System.PullRequest.PullRequestNumber) create-testing-build'
-  - ${{ if eq(variables.enabletesting, 'true') }}:
-    - template: ./sync-source.yml
-      parameters:
-        artifactSource: $(parameters.artifactSource)
-        needSubmodules: 'true'
-    - template: ./mergebot.yml
-      parameters:
-        matchLabel: 'testing-merge'
-    - template: ./build-single.yml
-      parameters:
-        artifactSource: 'false'
-        cache: 'false'

.ci/templates/format-check.yml

@@ -1,14 +0,0 @@
-parameters:
-  artifactSource: 'true'
-
-steps:
-- template: ./sync-source.yml
-  parameters:
-    artifactSource: $(parameters.artifactSource)
-    needSubmodules: 'false'
-- task: DockerInstaller@0
-  displayName: 'Prepare Environment'
-  inputs:
-    dockerVersion: '17.09.0-ce'
-- script: chmod a+x ./.ci/scripts/format/exec.sh && ./.ci/scripts/format/exec.sh
-  displayName: 'Verify Formatting'

.ci/templates/merge.yml

@@ -1,46 +0,0 @@
-jobs:
-- job: merge
-  displayName: 'pull requests'
-  steps:
-  - checkout: self
-    submodules: recursive
-  - template: ./mergebot.yml
-    parameters:
-      matchLabel: '$(BuildName)-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 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)
-    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.yml

@@ -1,15 +0,0 @@
-parameters:
-  matchLabel: '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'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
-      arguments: '${{ parameters.matchLabel }} patches'
-      workingDirectory: '$(System.DefaultWorkingDirectory)'

.ci/templates/retrieve-artifact-source.yml

@@ -1,16 +0,0 @@
-steps:
-- checkout: none
-- task: DownloadPipelineArtifact@2
-  displayName: 'Download Source'
-  inputs:
-    artifactName: 'yuzu-$(BuildName)-source'
-    buildType: 'current'
-    targetPath: '$(Build.ArtifactStagingDirectory)'
-- script: rm -rf $(System.DefaultWorkingDirectory) && mkdir $(System.DefaultWorkingDirectory)
-  displayName: 'Clean Working Directory'
-- task: ExtractFiles@1
-  displayName: 'Prepare Source'
-  inputs:
-    archiveFilePatterns: '$(Build.ArtifactStagingDirectory)/*.7z'
-    destinationFolder: '$(System.DefaultWorkingDirectory)'
-    cleanDestinationFolder: false

.ci/templates/retrieve-master-source.yml

@@ -1,11 +0,0 @@
-parameters:
-  needSubmodules: 'true'
-
-steps:
-- checkout: self
-  displayName: 'Checkout Recursive'
-  submodules: recursive
-#  condition: eq(parameters.needSubmodules, 'true')
-#- checkout: self
-#  displayName: 'Checkout Fast'
-#  condition: ne(parameters.needSubmodules, 'true')

.ci/templates/sync-source.yml

@@ -1,7 +0,0 @@
-steps:
-- ${{ if eq(parameters.artifactSource, 'true') }}:
-  - template: ./retrieve-artifact-source.yml
-- ${{ if ne(parameters.artifactSource, 'true') }}:
-  - template: ./retrieve-master-source.yml
-    parameters:
-      needSubmodules: $(parameters.needSubmodules)

.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-repo-sync.yml

@@ -1,19 +0,0 @@
-trigger:
-- master
-
-jobs:
-- job: copy
-  displayName: 'Sync Repository'
-  pool:
-    vmImage: 'ubuntu-latest'
-  steps:
-  - script: echo 'https://$(GitUsername):$(GitAccessToken)@dev.azure.com' > $HOME/.git-credentials
-    displayName: 'Load Credentials'
-  - script: git config --global credential.helper store
-    displayName: 'Register Credential Helper'
-  - script: git remote add other $(GitRepoPushChangesURL)
-    displayName: 'Register Repository'
-  - script: git push --force other HEAD:$(GitPushBranch)
-    displayName: 'Update Code'
-  - script: rm -rf $HOME/.git-credentials
-    displayName: 'Clear Cached Credentials'

.ci/yuzu-verify.yml

@@ -1,20 +0,0 @@
-stages:
-- stage: format
-  displayName: 'format'
-  jobs:
-  - job: format
-    displayName: 'clang'
-    pool:
-      vmImage: ubuntu-latest
-    steps:
-    - template: ./templates/format-check.yml
-      parameters:
-        artifactSource: 'false'
-- stage: build
-  displayName: 'build'
-  dependsOn: format
-  jobs:
-  - template: ./templates/build-standard.yml
-    parameters:
-      cache: 'false'
-  - template: ./templates/build-testing.yml

CMakeModules/GenerateSCMRev.cmake

@@ -81,10 +81,7 @@ set(HASH_FILES
     "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
     "${VIDEO_CORE}/shader/decode/shift.cpp"
     "${VIDEO_CORE}/shader/decode/video.cpp"
-    "${VIDEO_CORE}/shader/decode/warp.cpp"
     "${VIDEO_CORE}/shader/decode/xmad.cpp"
-    "${VIDEO_CORE}/shader/control_flow.cpp"
-    "${VIDEO_CORE}/shader/control_flow.h"
     "${VIDEO_CORE}/shader/decode.cpp"
     "${VIDEO_CORE}/shader/node.h"
     "${VIDEO_CORE}/shader/node_helper.cpp"

README.md

@@ -2,7 +2,6 @@ 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/).
 

src/audio_core/audio_renderer.cpp

@@ -73,15 +73,13 @@ private:
     EffectInStatus info{};
 };
 AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                             Kernel::SharedPtr<Kernel::WritableEvent> buffer_event,
-                             std::size_t instance_number)
+                             Kernel::SharedPtr<Kernel::WritableEvent> buffer_event)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
       effects(params.effect_count) {
 
     audio_out = std::make_unique<AudioCore::AudioOut>();
     stream = audio_out->OpenStream(core_timing, STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS,
-                                   fmt::format("AudioRenderer-Instance{}", instance_number),
-                                   [=]() { buffer_event->Signal(); });
+                                   "AudioRenderer", [=]() { buffer_event->Signal(); });
     audio_out->StartStream(stream);
 
     QueueMixedBuffer(0);

src/audio_core/audio_renderer.h

@@ -215,8 +215,7 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size
 class AudioRenderer {
 public:
     AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                  Kernel::SharedPtr<Kernel::WritableEvent> buffer_event,
-                  std::size_t instance_number);
+                  Kernel::SharedPtr<Kernel::WritableEvent> buffer_event);
     ~AudioRenderer();
 
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);

src/common/CMakeLists.txt

@@ -55,10 +55,7 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
       "${VIDEO_CORE}/shader/decode/shift.cpp"
       "${VIDEO_CORE}/shader/decode/video.cpp"
-      "${VIDEO_CORE}/shader/decode/warp.cpp"
       "${VIDEO_CORE}/shader/decode/xmad.cpp"
-      "${VIDEO_CORE}/shader/control_flow.cpp"
-      "${VIDEO_CORE}/shader/control_flow.h"
       "${VIDEO_CORE}/shader/decode.cpp"
       "${VIDEO_CORE}/shader/node.h"
       "${VIDEO_CORE}/shader/node_helper.cpp"

src/common/alignment.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include <cstddef>
-#include <memory>
 #include <type_traits>
 
 namespace Common {
@@ -38,63 +37,4 @@ constexpr bool IsWordAligned(T value) {
     return (value & 0b11) == 0;
 }
 
-template <typename T, std::size_t Align = 16>
-class AlignmentAllocator {
-public:
-    using value_type = T;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
-
-    using pointer = T*;
-    using const_pointer = const T*;
-
-    using reference = T&;
-    using const_reference = const T&;
-
-public:
-    pointer address(reference r) noexcept {
-        return std::addressof(r);
-    }
-
-    const_pointer address(const_reference r) const noexcept {
-        return std::addressof(r);
-    }
-
-    pointer allocate(size_type n) {
-        return static_cast<pointer>(::operator new (n, std::align_val_t{Align}));
-    }
-
-    void deallocate(pointer p, size_type) {
-        ::operator delete (p, std::align_val_t{Align});
-    }
-
-    void construct(pointer p, const value_type& wert) {
-        new (p) value_type(wert);
-    }
-
-    void destroy(pointer p) {
-        p->~value_type();
-    }
-
-    size_type max_size() const noexcept {
-        return size_type(-1) / sizeof(value_type);
-    }
-
-    template <typename T2>
-    struct rebind {
-        using other = AlignmentAllocator<T2, Align>;
-    };
-
-    bool operator!=(const AlignmentAllocator<T, Align>& other) const noexcept {
-        return !(*this == other);
-    }
-
-    // Returns true if and only if storage allocated from *this
-    // can be deallocated from other, and vice versa.
-    // Always returns true for stateless allocators.
-    bool operator==(const AlignmentAllocator<T, Align>& other) const noexcept {
-        return true;
-    }
-};
-
 } // namespace Common

src/core/CMakeLists.txt

@@ -111,8 +111,6 @@ add_library(core STATIC
     frontend/scope_acquire_window_context.h
     gdbstub/gdbstub.cpp
     gdbstub/gdbstub.h
-    hardware_interrupt_manager.cpp
-    hardware_interrupt_manager.h
     hle/ipc.h
     hle/ipc_helpers.h
     hle/kernel/address_arbiter.cpp
@@ -374,7 +372,6 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvmap.h
     hle/service/nvdrv/interface.cpp
     hle/service/nvdrv/interface.h
-    hle/service/nvdrv/nvdata.h
     hle/service/nvdrv/nvdrv.cpp
     hle/service/nvdrv/nvdrv.h
     hle/service/nvdrv/nvmemp.cpp

src/core/arm/arm_interface.h

@@ -44,6 +44,13 @@ public:
     /// Step CPU by one instruction
     virtual void Step() = 0;
 
+    /// Maps a backing memory region for the CPU
+    virtual void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                                  Kernel::VMAPermission perms) = 0;
+
+    /// Unmaps a region of memory that was previously mapped using MapBackingMemory
+    virtual void UnmapMemory(VAddr address, std::size_t size) = 0;
+
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
 

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -177,6 +177,15 @@ ARM_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
 
+void ARM_Dynarmic::MapBackingMemory(u64 address, std::size_t size, u8* memory,
+                                    Kernel::VMAPermission perms) {
+    inner_unicorn.MapBackingMemory(address, size, memory, perms);
+}
+
+void ARM_Dynarmic::UnmapMemory(u64 address, std::size_t size) {
+    inner_unicorn.UnmapMemory(address, size);
+}
+
 void ARM_Dynarmic::SetPC(u64 pc) {
     jit->SetPC(pc);
 }

src/core/arm/dynarmic/arm_dynarmic.h

@@ -23,6 +23,9 @@ public:
     ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
     ~ARM_Dynarmic() override;
 
+    void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                          Kernel::VMAPermission perms) override;
+    void UnmapMemory(u64 address, std::size_t size) override;
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;

src/core/arm/unicorn/arm_unicorn.cpp

@@ -50,14 +50,11 @@ static void CodeHook(uc_engine* uc, uint64_t address, uint32_t size, void* user_
 
 static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value,
                                void* user_data) {
-    auto* const system = static_cast<System*>(user_data);
-
     ARM_Interface::ThreadContext ctx{};
-    system->CurrentArmInterface().SaveContext(ctx);
+    Core::CurrentArmInterface().SaveContext(ctx);
     ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x{:X}, pc=0x{:X}, lr=0x{:X}", addr,
                ctx.pc, ctx.cpu_registers[30]);
-
-    return false;
+    return {};
 }
 
 ARM_Unicorn::ARM_Unicorn(System& system) : system{system} {
@@ -68,7 +65,7 @@ ARM_Unicorn::ARM_Unicorn(System& system) : system{system} {
 
     uc_hook hook{};
     CHECKED(uc_hook_add(uc, &hook, UC_HOOK_INTR, (void*)InterruptHook, this, 0, -1));
-    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, &system, 0, -1));
+    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, this, 0, -1));
     if (GDBStub::IsServerEnabled()) {
         CHECKED(uc_hook_add(uc, &hook, UC_HOOK_CODE, (void*)CodeHook, this, 0, -1));
         last_bkpt_hit = false;
@@ -79,6 +76,15 @@ ARM_Unicorn::~ARM_Unicorn() {
     CHECKED(uc_close(uc));
 }
 
+void ARM_Unicorn::MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                                   Kernel::VMAPermission perms) {
+    CHECKED(uc_mem_map_ptr(uc, address, size, static_cast<u32>(perms), memory));
+}
+
+void ARM_Unicorn::UnmapMemory(VAddr address, std::size_t size) {
+    CHECKED(uc_mem_unmap(uc, address, size));
+}
+
 void ARM_Unicorn::SetPC(u64 pc) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &pc));
 }

src/core/arm/unicorn/arm_unicorn.h

@@ -18,6 +18,9 @@ public:
     explicit ARM_Unicorn(System& system);
     ~ARM_Unicorn() override;
 
+    void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                          Kernel::VMAPermission perms) override;
+    void UnmapMemory(VAddr address, std::size_t size) override;
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;

src/core/core.cpp

@@ -19,7 +19,6 @@
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hardware_interrupt_manager.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
@@ -152,7 +151,7 @@ struct System::Impl {
         if (!renderer->Init()) {
             return ResultStatus::ErrorVideoCore;
         }
-        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
+
         gpu_core = VideoCore::CreateGPU(system);
 
         is_powered_on = true;
@@ -299,7 +298,6 @@ struct System::Impl {
     std::unique_ptr<VideoCore::RendererBase> renderer;
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
-    std::unique_ptr<Core::Hardware::InterruptManager> interrupt_manager;
     CpuCoreManager cpu_core_manager;
     bool is_powered_on = false;
 
@@ -446,14 +444,6 @@ const Tegra::GPU& System::GPU() const {
     return *impl->gpu_core;
 }
 
-Core::Hardware::InterruptManager& System::InterruptManager() {
-    return *impl->interrupt_manager;
-}
-
-const Core::Hardware::InterruptManager& System::InterruptManager() const {
-    return *impl->interrupt_manager;
-}
-
 VideoCore::RendererBase& System::Renderer() {
     return *impl->renderer;
 }

src/core/core.h

@@ -70,10 +70,6 @@ namespace Core::Timing {
 class CoreTiming;
 }
 
-namespace Core::Hardware {
-class InterruptManager;
-}
-
 namespace Core {
 
 class ARM_Interface;
@@ -238,12 +234,6 @@ public:
     /// Provides a constant reference to the core timing instance.
     const Timing::CoreTiming& CoreTiming() const;
 
-    /// Provides a reference to the interrupt manager instance.
-    Core::Hardware::InterruptManager& InterruptManager();
-
-    /// Provides a constant reference to the interrupt manager instance.
-    const Core::Hardware::InterruptManager& InterruptManager() const;
-
     /// Provides a reference to the kernel instance.
     Kernel::KernelCore& Kernel();
 
@@ -337,6 +327,10 @@ private:
     static System s_instance;
 };
 
+inline ARM_Interface& CurrentArmInterface() {
+    return System::GetInstance().CurrentArmInterface();
+}
+
 inline Kernel::Process* CurrentProcess() {
     return System::GetInstance().CurrentProcess();
 }

src/core/core_cpu.cpp

@@ -53,12 +53,16 @@ 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} {
+    if (Settings::values.cpu_jit_enabled) {
 #ifdef ARCHITECTURE_x86_64
-    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
+        arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
-    arm_interface = std::make_unique<ARM_Unicorn>(system);
-    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+        arm_interface = std::make_unique<ARM_Unicorn>(system);
+        LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
+    } else {
+        arm_interface = std::make_unique<ARM_Unicorn>(system);
+    }
 
     scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
 }
@@ -66,12 +70,15 @@ Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_ba
 Cpu::~Cpu() = default;
 
 std::unique_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(std::size_t num_cores) {
+    if (Settings::values.cpu_jit_enabled) {
 #ifdef ARCHITECTURE_x86_64
-    return std::make_unique<DynarmicExclusiveMonitor>(num_cores);
+        return std::make_unique<DynarmicExclusiveMonitor>(num_cores);
 #else
-    // TODO(merry): Passthrough exclusive monitor
-    return nullptr;
+        return nullptr; // TODO(merry): Passthrough exclusive monitor
 #endif
+    } else {
+        return nullptr; // TODO(merry): Passthrough exclusive monitor
+    }
 }
 
 void Cpu::RunLoop(bool tight_loop) {

src/core/file_sys/program_metadata.cpp

@@ -94,10 +94,6 @@ u64 ProgramMetadata::GetFilesystemPermissions() const {
     return aci_file_access.permissions;
 }
 
-u32 ProgramMetadata::GetSystemResourceSize() const {
-    return npdm_header.system_resource_size;
-}
-
 const ProgramMetadata::KernelCapabilityDescriptors& ProgramMetadata::GetKernelCapabilities() const {
     return aci_kernel_capabilities;
 }

src/core/file_sys/program_metadata.h

@@ -58,7 +58,6 @@ public:
     u32 GetMainThreadStackSize() const;
     u64 GetTitleID() const;
     u64 GetFilesystemPermissions() const;
-    u32 GetSystemResourceSize() const;
     const KernelCapabilityDescriptors& GetKernelCapabilities() const;
 
     void Print() const;
@@ -77,8 +76,7 @@ private:
         u8 reserved_3;
         u8 main_thread_priority;
         u8 main_thread_cpu;
-        std::array<u8, 4> reserved_4;
-        u32_le system_resource_size;
+        std::array<u8, 8> reserved_4;
         u32_le process_category;
         u32_le main_stack_size;
         std::array<u8, 0x10> application_name;

src/core/hardware_interrupt_manager.cpp

@@ -1,30 +0,0 @@
-// Copyright 2019 Yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hardware_interrupt_manager.h"
-#include "core/hle/service/nvdrv/interface.h"
-#include "core/hle/service/sm/sm.h"
-
-namespace Core::Hardware {
-
-InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
-    gpu_interrupt_event =
-        system.CoreTiming().RegisterEvent("GPUInterrupt", [this](u64 message, s64) {
-            auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
-            const u32 syncpt = static_cast<u32>(message >> 32);
-            const u32 value = static_cast<u32>(message);
-            nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
-        });
-}
-
-InterruptManager::~InterruptManager() = default;
-
-void InterruptManager::GPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
-    const u64 msg = (static_cast<u64>(syncpoint_id) << 32ULL) | value;
-    system.CoreTiming().ScheduleEvent(10, gpu_interrupt_event, msg);
-}
-
-} // namespace Core::Hardware

src/core/hardware_interrupt_manager.h

@@ -1,31 +0,0 @@
-// Copyright 2019 Yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Core::Timing {
-struct EventType;
-}
-
-namespace Core::Hardware {
-
-class InterruptManager {
-public:
-    explicit InterruptManager(Core::System& system);
-    ~InterruptManager();
-
-    void GPUInterruptSyncpt(u32 syncpoint_id, u32 value);
-
-private:
-    Core::System& system;
-    Core::Timing::EventType* gpu_interrupt_event{};
-};
-
-} // namespace Core::Hardware

src/core/hle/kernel/code_set.h

@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include "core/hle/kernel/physical_memory.h"
 
 namespace Kernel {
 
@@ -78,7 +77,7 @@ struct CodeSet final {
     }
 
     /// The overall data that backs this code set.
-    Kernel::PhysicalMemory memory;
+    std::vector<u8> memory;
 
     /// The segments that comprise this code set.
     std::array<Segment, 3> segments;

src/core/hle/kernel/physical_memory.h

@@ -1,19 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/alignment.h"
-
-namespace Kernel {
-
-// This encapsulation serves 2 purposes:
-// - First, to encapsulate host physical memory under a single type and set an
-// standard for managing it.
-// - Second to ensure all host backing memory used is aligned to 256 bytes due
-// to strict alignment restrictions on GPU memory.
-
-using PhysicalMemory = std::vector<u8, Common::AlignmentAllocator<u8, 256>>;
-
-} // namespace Kernel

src/core/hle/kernel/process.cpp

@@ -129,17 +129,20 @@ u64 Process::GetTotalPhysicalMemoryAvailable() const {
     return vm_manager.GetTotalPhysicalMemoryAvailable();
 }
 
-u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
-    return GetTotalPhysicalMemoryAvailable() - GetSystemResourceSize();
+u64 Process::GetTotalPhysicalMemoryAvailableWithoutMmHeap() const {
+    // TODO: Subtract the personal heap size from this when the
+    //       personal heap is implemented.
+    return GetTotalPhysicalMemoryAvailable();
 }
 
 u64 Process::GetTotalPhysicalMemoryUsed() const {
-    return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size +
-           GetSystemResourceUsage();
+    return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size;
 }
 
-u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
-    return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();
+u64 Process::GetTotalPhysicalMemoryUsedWithoutMmHeap() const {
+    // TODO: Subtract the personal heap size from this when the
+    //       personal heap is implemented.
+    return GetTotalPhysicalMemoryUsed();
 }
 
 void Process::RegisterThread(const Thread* thread) {
@@ -169,7 +172,6 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
     program_id = metadata.GetTitleID();
     ideal_core = metadata.GetMainThreadCore();
     is_64bit_process = metadata.Is64BitProgram();
-    system_resource_size = metadata.GetSystemResourceSize();
 
     vm_manager.Reset(metadata.GetAddressSpaceType());
 
@@ -184,11 +186,19 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
 }
 
 void Process::Run(s32 main_thread_priority, u64 stack_size) {
-    AllocateMainThreadStack(stack_size);
-    tls_region_address = CreateTLSRegion();
+    // The kernel always ensures that the given stack size is page aligned.
+    main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);
+
+    // Allocate and map the main thread stack
+    // TODO(bunnei): This is heap area that should be allocated by the kernel and not mapped as part
+    // of the user address space.
+    const VAddr mapping_address = vm_manager.GetTLSIORegionEndAddress() - main_thread_stack_size;
+    vm_manager
+        .MapMemoryBlock(mapping_address, std::make_shared<std::vector<u8>>(main_thread_stack_size),
+                        0, main_thread_stack_size, MemoryState::Stack)
+        .Unwrap();
 
     vm_manager.LogLayout();
-
     ChangeStatus(ProcessStatus::Running);
 
     SetupMainThread(*this, kernel, main_thread_priority);
@@ -218,9 +228,6 @@ void Process::PrepareForTermination() {
     stop_threads(system.Scheduler(2).GetThreadList());
     stop_threads(system.Scheduler(3).GetThreadList());
 
-    FreeTLSRegion(tls_region_address);
-    tls_region_address = 0;
-
     ChangeStatus(ProcessStatus::Exited);
 }
 
@@ -247,7 +254,7 @@ VAddr Process::CreateTLSRegion() {
         ASSERT(region_address.Succeeded());
 
         const auto map_result = vm_manager.MapMemoryBlock(
-            *region_address, std::make_shared<PhysicalMemory>(Memory::PAGE_SIZE), 0,
+            *region_address, std::make_shared<std::vector<u8>>(Memory::PAGE_SIZE), 0,
             Memory::PAGE_SIZE, MemoryState::ThreadLocal);
         ASSERT(map_result.Succeeded());
 
@@ -277,7 +284,7 @@ void Process::FreeTLSRegion(VAddr tls_address) {
 }
 
 void Process::LoadModule(CodeSet module_, VAddr base_addr) {
-    const auto memory = std::make_shared<PhysicalMemory>(std::move(module_.memory));
+    const auto memory = std::make_shared<std::vector<u8>>(std::move(module_.memory));
 
     const auto MapSegment = [&](const CodeSet::Segment& segment, VMAPermission permissions,
                                 MemoryState memory_state) {
@@ -320,16 +327,4 @@ void Process::ChangeStatus(ProcessStatus new_status) {
     WakeupAllWaitingThreads();
 }
 
-void Process::AllocateMainThreadStack(u64 stack_size) {
-    // The kernel always ensures that the given stack size is page aligned.
-    main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);
-
-    // Allocate and map the main thread stack
-    const VAddr mapping_address = vm_manager.GetTLSIORegionEndAddress() - main_thread_stack_size;
-    vm_manager
-        .MapMemoryBlock(mapping_address, std::make_shared<PhysicalMemory>(main_thread_stack_size),
-                        0, main_thread_stack_size, MemoryState::Stack)
-        .Unwrap();
-}
-
 } // namespace Kernel

src/core/hle/kernel/process.h

@@ -135,11 +135,6 @@ public:
         return mutex;
     }
 
-    /// Gets the address to the process' dedicated TLS region.
-    VAddr GetTLSRegionAddress() const {
-        return tls_region_address;
-    }
-
     /// Gets the current status of the process
     ProcessStatus GetStatus() const {
         return status;
@@ -173,24 +168,8 @@ public:
         return capabilities.GetPriorityMask();
     }
 
-    /// Gets the amount of secure memory to allocate for memory management.
-    u32 GetSystemResourceSize() const {
-        return system_resource_size;
-    }
-
-    /// Gets the amount of secure memory currently in use for memory management.
-    u32 GetSystemResourceUsage() const {
-        // On hardware, this returns the amount of system resource memory that has
-        // been used by the kernel. This is problematic for Yuzu to emulate, because
-        // system resource memory is used for page tables -- and yuzu doesn't really
-        // have a way to calculate how much memory is required for page tables for
-        // the current process at any given time.
-        // TODO: Is this even worth implementing? Games may retrieve this value via
-        // an SDK function that gets used + available system resource size for debug
-        // or diagnostic purposes. However, it seems unlikely that a game would make
-        // decisions based on how much system memory is dedicated to its page tables.
-        // Is returning a value other than zero wise?
-        return 0;
+    u32 IsVirtualMemoryEnabled() const {
+        return is_virtual_address_memory_enabled;
     }
 
     /// Whether this process is an AArch64 or AArch32 process.
@@ -217,15 +196,15 @@ public:
     u64 GetTotalPhysicalMemoryAvailable() const;
 
     /// Retrieves the total physical memory available to this process in bytes,
-    /// without the size of the personal system resource heap added to it.
-    u64 GetTotalPhysicalMemoryAvailableWithoutSystemResource() const;
+    /// without the size of the personal heap added to it.
+    u64 GetTotalPhysicalMemoryAvailableWithoutMmHeap() const;
 
     /// Retrieves the total physical memory used by this process in bytes.
     u64 GetTotalPhysicalMemoryUsed() const;
 
     /// Retrieves the total physical memory used by this process in bytes,
-    /// without the size of the personal system resource heap added to it.
-    u64 GetTotalPhysicalMemoryUsedWithoutSystemResource() const;
+    /// without the size of the personal heap added to it.
+    u64 GetTotalPhysicalMemoryUsedWithoutMmHeap() const;
 
     /// Gets the list of all threads created with this process as their owner.
     const std::list<const Thread*>& GetThreadList() const {
@@ -301,9 +280,6 @@ private:
     /// a process signal.
     void ChangeStatus(ProcessStatus new_status);
 
-    /// Allocates the main thread stack for the process, given the stack size in bytes.
-    void AllocateMainThreadStack(u64 stack_size);
-
     /// Memory manager for this process.
     Kernel::VMManager vm_manager;
 
@@ -322,16 +298,12 @@ private:
     /// Title ID corresponding to the process
     u64 program_id = 0;
 
-    /// Specifies additional memory to be reserved for the process's memory management by the
-    /// system. When this is non-zero, secure memory is allocated and used for page table allocation
-    /// instead of using the normal global page tables/memory block management.
-    u32 system_resource_size = 0;
-
     /// Resource limit descriptor for this process
     SharedPtr<ResourceLimit> resource_limit;
 
     /// The ideal CPU core for this process, threads are scheduled on this core by default.
     u8 ideal_core = 0;
+    u32 is_virtual_address_memory_enabled = 0;
 
     /// The Thread Local Storage area is allocated as processes create threads,
     /// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
@@ -366,9 +338,6 @@ private:
     /// variable related facilities.
     Mutex mutex;
 
-    /// Address indicating the location of the process' dedicated TLS region.
-    VAddr tls_region_address = 0;
-
     /// Random values for svcGetInfo RandomEntropy
     std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy{};
 

src/core/hle/kernel/shared_memory.cpp

@@ -28,7 +28,7 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process* owner_
     shared_memory->other_permissions = other_permissions;
 
     if (address == 0) {
-        shared_memory->backing_block = std::make_shared<Kernel::PhysicalMemory>(size);
+        shared_memory->backing_block = std::make_shared<std::vector<u8>>(size);
         shared_memory->backing_block_offset = 0;
 
         // Refresh the address mappings for the current process.
@@ -59,8 +59,8 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process* owner_
 }
 
 SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
-    KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
-    u64 size, MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
+    KernelCore& kernel, std::shared_ptr<std::vector<u8>> heap_block, std::size_t offset, u64 size,
+    MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
     SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
 
     shared_memory->owner_process = nullptr;

src/core/hle/kernel/shared_memory.h

@@ -10,7 +10,6 @@
 
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/physical_memory.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
 
@@ -63,10 +62,12 @@ public:
      * block.
      * @param name Optional object name, used for debugging purposes.
      */
-    static SharedPtr<SharedMemory> CreateForApplet(
-        KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
-        u64 size, MemoryPermission permissions, MemoryPermission other_permissions,
-        std::string name = "Unknown Applet");
+    static SharedPtr<SharedMemory> CreateForApplet(KernelCore& kernel,
+                                                   std::shared_ptr<std::vector<u8>> heap_block,
+                                                   std::size_t offset, u64 size,
+                                                   MemoryPermission permissions,
+                                                   MemoryPermission other_permissions,
+                                                   std::string name = "Unknown Applet");
 
     std::string GetTypeName() const override {
         return "SharedMemory";
@@ -134,7 +135,7 @@ private:
     ~SharedMemory() override;
 
     /// Backing memory for this shared memory block.
-    std::shared_ptr<PhysicalMemory> backing_block;
+    std::shared_ptr<std::vector<u8>> backing_block;
     /// Offset into the backing block for this shared memory.
     std::size_t backing_block_offset = 0;
     /// Size of the memory block. Page-aligned.

src/core/hle/kernel/svc.cpp

@@ -318,14 +318,7 @@ static ResultCode UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_ad
         return result;
     }
 
-    const auto unmap_res = vm_manager.UnmapRange(dst_addr, size);
-
-    // Reprotect the source mapping on success
-    if (unmap_res.IsSuccess()) {
-        ASSERT(vm_manager.ReprotectRange(src_addr, size, VMAPermission::ReadWrite).IsSuccess());
-    }
-
-    return unmap_res;
+    return vm_manager.UnmapRange(dst_addr, size);
 }
 
 /// Connect to an OS service given the port name, returns the handle to the port to out
@@ -736,16 +729,16 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
         StackRegionBaseAddr = 14,
         StackRegionSize = 15,
         // 3.0.0+
-        SystemResourceSize = 16,
-        SystemResourceUsage = 17,
+        IsVirtualAddressMemoryEnabled = 16,
+        PersonalMmHeapUsage = 17,
         TitleId = 18,
         // 4.0.0+
         PrivilegedProcessId = 19,
         // 5.0.0+
         UserExceptionContextAddr = 20,
         // 6.0.0+
-        TotalPhysicalMemoryAvailableWithoutSystemResource = 21,
-        TotalPhysicalMemoryUsedWithoutSystemResource = 22,
+        TotalPhysicalMemoryAvailableWithoutMmHeap = 21,
+        TotalPhysicalMemoryUsedWithoutMmHeap = 22,
     };
 
     const auto info_id_type = static_cast<GetInfoType>(info_id);
@@ -763,12 +756,12 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
     case GetInfoType::StackRegionSize:
     case GetInfoType::TotalPhysicalMemoryAvailable:
     case GetInfoType::TotalPhysicalMemoryUsed:
-    case GetInfoType::SystemResourceSize:
-    case GetInfoType::SystemResourceUsage:
+    case GetInfoType::IsVirtualAddressMemoryEnabled:
+    case GetInfoType::PersonalMmHeapUsage:
     case GetInfoType::TitleId:
     case GetInfoType::UserExceptionContextAddr:
-    case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
-    case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource: {
+    case GetInfoType::TotalPhysicalMemoryAvailableWithoutMmHeap:
+    case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap: {
         if (info_sub_id != 0) {
             return ERR_INVALID_ENUM_VALUE;
         }
@@ -829,13 +822,8 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             *result = process->GetTotalPhysicalMemoryUsed();
             return RESULT_SUCCESS;
 
-        case GetInfoType::SystemResourceSize:
-            *result = process->GetSystemResourceSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::SystemResourceUsage:
-            LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query system resource usage");
-            *result = process->GetSystemResourceUsage();
+        case GetInfoType::IsVirtualAddressMemoryEnabled:
+            *result = process->IsVirtualMemoryEnabled();
             return RESULT_SUCCESS;
 
         case GetInfoType::TitleId:
@@ -843,15 +831,17 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             return RESULT_SUCCESS;
 
         case GetInfoType::UserExceptionContextAddr:
-            *result = process->GetTLSRegionAddress();
+            LOG_WARNING(Kernel_SVC,
+                        "(STUBBED) Attempted to query user exception context address, returned 0");
+            *result = 0;
             return RESULT_SUCCESS;
 
-        case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
-            *result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();
+        case GetInfoType::TotalPhysicalMemoryAvailableWithoutMmHeap:
+            *result = process->GetTotalPhysicalMemoryAvailable();
             return RESULT_SUCCESS;
 
-        case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource:
-            *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
+        case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap:
+            *result = process->GetTotalPhysicalMemoryUsedWithoutMmHeap();
             return RESULT_SUCCESS;
 
         default:
@@ -956,86 +946,6 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
     }
 }
 
-/// Maps memory at a desired address
-static ResultCode MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
-    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
-
-    if (!Common::Is4KBAligned(addr)) {
-        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (!Common::Is4KBAligned(size)) {
-        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
-        return ERR_INVALID_SIZE;
-    }
-
-    if (size == 0) {
-        LOG_ERROR(Kernel_SVC, "Size is zero");
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!(addr < addr + size)) {
-        LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    Process* const current_process = system.Kernel().CurrentProcess();
-    auto& vm_manager = current_process->VMManager();
-
-    if (current_process->GetSystemResourceSize() == 0) {
-        LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
-        return ERR_INVALID_STATE;
-    }
-
-    if (!vm_manager.IsWithinMapRegion(addr, size)) {
-        LOG_ERROR(Kernel_SVC, "Range not within map region");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return vm_manager.MapPhysicalMemory(addr, size);
-}
-
-/// Unmaps memory previously mapped via MapPhysicalMemory
-static ResultCode UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
-    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
-
-    if (!Common::Is4KBAligned(addr)) {
-        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (!Common::Is4KBAligned(size)) {
-        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
-        return ERR_INVALID_SIZE;
-    }
-
-    if (size == 0) {
-        LOG_ERROR(Kernel_SVC, "Size is zero");
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!(addr < addr + size)) {
-        LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    Process* const current_process = system.Kernel().CurrentProcess();
-    auto& vm_manager = current_process->VMManager();
-
-    if (current_process->GetSystemResourceSize() == 0) {
-        LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
-        return ERR_INVALID_STATE;
-    }
-
-    if (!vm_manager.IsWithinMapRegion(addr, size)) {
-        LOG_ERROR(Kernel_SVC, "Range not within map region");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return vm_manager.UnmapPhysicalMemory(addr, size);
-}
-
 /// Sets the thread activity
 static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 activity) {
     LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, activity=0x{:08X}", handle, activity);
@@ -1737,8 +1647,8 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
 // Wait for an address (via Address Arbiter)
 static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type, s32 value,
                                  s64 timeout) {
-    LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, timeout={}", address,
-              type, value, timeout);
+    LOG_WARNING(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, timeout={}",
+                address, type, value, timeout);
 
     // If the passed address is a kernel virtual address, return invalid memory state.
     if (Memory::IsKernelVirtualAddress(address)) {
@@ -1760,8 +1670,8 @@ static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type,
 // Signals to an address (via Address Arbiter)
 static ResultCode SignalToAddress(Core::System& system, VAddr address, u32 type, s32 value,
                                   s32 num_to_wake) {
-    LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, num_to_wake=0x{:X}",
-              address, type, value, num_to_wake);
+    LOG_WARNING(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, num_to_wake=0x{:X}",
+                address, type, value, num_to_wake);
 
     // If the passed address is a kernel virtual address, return invalid memory state.
     if (Memory::IsKernelVirtualAddress(address)) {
@@ -2393,8 +2303,8 @@ static const FunctionDef SVC_Table[] = {
     {0x29, SvcWrap<GetInfo>, "GetInfo"},
     {0x2A, nullptr, "FlushEntireDataCache"},
     {0x2B, nullptr, "FlushDataCache"},
-    {0x2C, SvcWrap<MapPhysicalMemory>, "MapPhysicalMemory"},
-    {0x2D, SvcWrap<UnmapPhysicalMemory>, "UnmapPhysicalMemory"},
+    {0x2C, nullptr, "MapPhysicalMemory"},
+    {0x2D, nullptr, "UnmapPhysicalMemory"},
     {0x2E, nullptr, "GetFutureThreadInfo"},
     {0x2F, nullptr, "GetLastThreadInfo"},
     {0x30, SvcWrap<GetResourceLimitLimitValue>, "GetResourceLimitLimitValue"},

src/core/hle/kernel/svc_wrap.h

@@ -32,11 +32,6 @@ void SvcWrap(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0)).raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1)).raw);
-}
-
 template <ResultCode func(Core::System&, u32)>
 void SvcWrap(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);

src/core/hle/kernel/transfer_memory.cpp

@@ -47,7 +47,7 @@ ResultCode TransferMemory::MapMemory(VAddr address, u64 size, MemoryPermission p
         return ERR_INVALID_STATE;
     }
 
-    backing_block = std::make_shared<PhysicalMemory>(size);
+    backing_block = std::make_shared<std::vector<u8>>(size);
 
     const auto map_state = owner_permissions == MemoryPermission::None
                                ? MemoryState::TransferMemoryIsolated

src/core/hle/kernel/transfer_memory.h

@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/physical_memory.h"
 
 union ResultCode;
 
@@ -83,7 +82,7 @@ private:
     ~TransferMemory() override;
 
     /// Memory block backing this instance.
-    std::shared_ptr<PhysicalMemory> backing_block;
+    std::shared_ptr<std::vector<u8>> backing_block;
 
     /// The base address for the memory managed by this instance.
     VAddr base_address = 0;

src/core/hle/kernel/vm_manager.cpp

@@ -5,15 +5,13 @@
 #include <algorithm>
 #include <iterator>
 #include <utility>
-#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/memory_hook.h"
+#include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/process.h"
-#include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
@@ -51,14 +49,10 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
         type != next.type) {
         return false;
     }
-    if ((attribute & MemoryAttribute::DeviceMapped) == MemoryAttribute::DeviceMapped) {
-        // TODO: Can device mapped memory be merged sanely?
-        // Not merging it may cause inaccuracies versus hardware when memory layout is queried.
+    if (type == VMAType::AllocatedMemoryBlock &&
+        (backing_block != next.backing_block || offset + size != next.offset)) {
         return false;
     }
-    if (type == VMAType::AllocatedMemoryBlock) {
-        return true;
-    }
     if (type == VMAType::BackingMemory && backing_memory + size != next.backing_memory) {
         return false;
     }
@@ -104,9 +98,9 @@ bool VMManager::IsValidHandle(VMAHandle handle) const {
 }
 
 ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
-                                                          std::shared_ptr<PhysicalMemory> block,
+                                                          std::shared_ptr<std::vector<u8>> block,
                                                           std::size_t offset, u64 size,
-                                                          MemoryState state, VMAPermission perm) {
+                                                          MemoryState state) {
     ASSERT(block != nullptr);
     ASSERT(offset + size <= block->size());
 
@@ -115,8 +109,17 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    system.ArmInterface(0).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+    system.ArmInterface(1).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+    system.ArmInterface(2).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+    system.ArmInterface(3).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+
     final_vma.type = VMAType::AllocatedMemoryBlock;
-    final_vma.permissions = perm;
+    final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.state = state;
     final_vma.backing_block = std::move(block);
     final_vma.offset = offset;
@@ -134,6 +137,11 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    system.ArmInterface(0).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+    system.ArmInterface(1).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+    system.ArmInterface(2).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+    system.ArmInterface(3).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+
     final_vma.type = VMAType::BackingMemory;
     final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.state = state;
@@ -222,6 +230,11 @@ ResultCode VMManager::UnmapRange(VAddr target, u64 size) {
 
     ASSERT(FindVMA(target)->second.size >= size);
 
+    system.ArmInterface(0).UnmapMemory(target, size);
+    system.ArmInterface(1).UnmapMemory(target, size);
+    system.ArmInterface(2).UnmapMemory(target, size);
+    system.ArmInterface(3).UnmapMemory(target, size);
+
     return RESULT_SUCCESS;
 }
 
@@ -261,7 +274,7 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
 
     if (heap_memory == nullptr) {
         // Initialize heap
-        heap_memory = std::make_shared<PhysicalMemory>(size);
+        heap_memory = std::make_shared<std::vector<u8>>(size);
         heap_end = heap_region_base + size;
     } else {
         UnmapRange(heap_region_base, GetCurrentHeapSize());
@@ -295,162 +308,6 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
     return MakeResult<VAddr>(heap_region_base);
 }
 
-ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
-    // Check how much memory we've already mapped.
-    const auto mapped_size_result = SizeOfAllocatedVMAsInRange(target, size);
-    if (mapped_size_result.Failed()) {
-        return mapped_size_result.Code();
-    }
-
-    // If we've already mapped the desired amount, return early.
-    const std::size_t mapped_size = *mapped_size_result;
-    if (mapped_size == size) {
-        return RESULT_SUCCESS;
-    }
-
-    // Check that we can map the memory we want.
-    const auto res_limit = system.CurrentProcess()->GetResourceLimit();
-    const u64 physmem_remaining = res_limit->GetMaxResourceValue(ResourceType::PhysicalMemory) -
-                                  res_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory);
-    if (physmem_remaining < (size - mapped_size)) {
-        return ERR_RESOURCE_LIMIT_EXCEEDED;
-    }
-
-    // Keep track of the memory regions we unmap.
-    std::vector<std::pair<u64, u64>> mapped_regions;
-    ResultCode result = RESULT_SUCCESS;
-
-    // Iterate, trying to map memory.
-    {
-        const auto end_addr = target + size;
-        const auto last_addr = end_addr - 1;
-        VAddr cur_addr = target;
-
-        auto iter = FindVMA(target);
-        ASSERT(iter != vma_map.end());
-
-        while (true) {
-            const auto& vma = iter->second;
-            const auto vma_start = vma.base;
-            const auto vma_end = vma_start + vma.size;
-            const auto vma_last = vma_end - 1;
-
-            // Map the memory block
-            const auto map_size = std::min(end_addr - cur_addr, vma_end - cur_addr);
-            if (vma.state == MemoryState::Unmapped) {
-                const auto map_res =
-                    MapMemoryBlock(cur_addr, std::make_shared<PhysicalMemory>(map_size), 0,
-                                   map_size, MemoryState::Heap, VMAPermission::ReadWrite);
-                result = map_res.Code();
-                if (result.IsError()) {
-                    break;
-                }
-
-                mapped_regions.emplace_back(cur_addr, map_size);
-            }
-
-            // Break once we hit the end of the range.
-            if (last_addr <= vma_last) {
-                break;
-            }
-
-            // Advance to the next block.
-            cur_addr = vma_end;
-            iter = FindVMA(cur_addr);
-            ASSERT(iter != vma_map.end());
-        }
-    }
-
-    // If we failed, unmap memory.
-    if (result.IsError()) {
-        for (const auto [unmap_address, unmap_size] : mapped_regions) {
-            ASSERT_MSG(UnmapRange(unmap_address, unmap_size).IsSuccess(),
-                       "Failed to unmap memory range.");
-        }
-
-        return result;
-    }
-
-    // Update amount of mapped physical memory.
-    physical_memory_mapped += size - mapped_size;
-
-    return RESULT_SUCCESS;
-}
-
-ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {
-    // Check how much memory is currently mapped.
-    const auto mapped_size_result = SizeOfUnmappablePhysicalMemoryInRange(target, size);
-    if (mapped_size_result.Failed()) {
-        return mapped_size_result.Code();
-    }
-
-    // If we've already unmapped all the memory, return early.
-    const std::size_t mapped_size = *mapped_size_result;
-    if (mapped_size == 0) {
-        return RESULT_SUCCESS;
-    }
-
-    // Keep track of the memory regions we unmap.
-    std::vector<std::pair<u64, u64>> unmapped_regions;
-    ResultCode result = RESULT_SUCCESS;
-
-    // Try to unmap regions.
-    {
-        const auto end_addr = target + size;
-        const auto last_addr = end_addr - 1;
-        VAddr cur_addr = target;
-
-        auto iter = FindVMA(target);
-        ASSERT(iter != vma_map.end());
-
-        while (true) {
-            const auto& vma = iter->second;
-            const auto vma_start = vma.base;
-            const auto vma_end = vma_start + vma.size;
-            const auto vma_last = vma_end - 1;
-
-            // Unmap the memory block
-            const auto unmap_size = std::min(end_addr - cur_addr, vma_end - cur_addr);
-            if (vma.state == MemoryState::Heap) {
-                result = UnmapRange(cur_addr, unmap_size);
-                if (result.IsError()) {
-                    break;
-                }
-
-                unmapped_regions.emplace_back(cur_addr, unmap_size);
-            }
-
-            // Break once we hit the end of the range.
-            if (last_addr <= vma_last) {
-                break;
-            }
-
-            // Advance to the next block.
-            cur_addr = vma_end;
-            iter = FindVMA(cur_addr);
-            ASSERT(iter != vma_map.end());
-        }
-    }
-
-    // If we failed, re-map regions.
-    // TODO: Preserve memory contents?
-    if (result.IsError()) {
-        for (const auto [map_address, map_size] : unmapped_regions) {
-            const auto remap_res =
-                MapMemoryBlock(map_address, std::make_shared<PhysicalMemory>(map_size), 0, map_size,
-                               MemoryState::Heap, VMAPermission::None);
-            ASSERT_MSG(remap_res.Succeeded(), "Failed to remap a memory block.");
-        }
-
-        return result;
-    }
-
-    // Update mapped amount
-    physical_memory_mapped -= mapped_size;
-
-    return RESULT_SUCCESS;
-}
-
 ResultCode VMManager::MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
     constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
     const auto src_check_result = CheckRangeState(
@@ -590,7 +447,7 @@ ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, Mem
     ASSERT_MSG(vma_offset + size <= vma->second.size,
                "Shared memory exceeds bounds of mapped block");
 
-    const std::shared_ptr<PhysicalMemory>& backing_block = vma->second.backing_block;
+    const std::shared_ptr<std::vector<u8>>& backing_block = vma->second.backing_block;
     const std::size_t backing_block_offset = vma->second.offset + vma_offset;
 
     CASCADE_RESULT(auto new_vma,
@@ -598,12 +455,12 @@ ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, Mem
     // Protect mirror with permissions from old region
     Reprotect(new_vma, vma->second.permissions);
     // Remove permissions from old region
-    ReprotectRange(src_addr, size, VMAPermission::None);
+    Reprotect(vma, VMAPermission::None);
 
     return RESULT_SUCCESS;
 }
 
-void VMManager::RefreshMemoryBlockMappings(const PhysicalMemory* block) {
+void VMManager::RefreshMemoryBlockMappings(const std::vector<u8>* block) {
     // If this ever proves to have a noticeable performance impact, allow users of the function to
     // specify a specific range of addresses to limit the scan to.
     for (const auto& p : vma_map) {
@@ -731,14 +588,14 @@ VMManager::VMAIter VMManager::SplitVMA(VMAIter vma_handle, u64 offset_in_vma) {
 VMManager::VMAIter VMManager::MergeAdjacent(VMAIter iter) {
     const VMAIter next_vma = std::next(iter);
     if (next_vma != vma_map.end() && iter->second.CanBeMergedWith(next_vma->second)) {
-        MergeAdjacentVMA(iter->second, next_vma->second);
+        iter->second.size += next_vma->second.size;
         vma_map.erase(next_vma);
     }
 
     if (iter != vma_map.begin()) {
         VMAIter prev_vma = std::prev(iter);
         if (prev_vma->second.CanBeMergedWith(iter->second)) {
-            MergeAdjacentVMA(prev_vma->second, iter->second);
+            prev_vma->second.size += iter->second.size;
             vma_map.erase(iter);
             iter = prev_vma;
         }
@@ -747,44 +604,6 @@ VMManager::VMAIter VMManager::MergeAdjacent(VMAIter iter) {
     return iter;
 }
 
-void VMManager::MergeAdjacentVMA(VirtualMemoryArea& left, const VirtualMemoryArea& right) {
-    ASSERT(left.CanBeMergedWith(right));
-
-    // Always merge allocated memory blocks, even when they don't share the same backing block.
-    if (left.type == VMAType::AllocatedMemoryBlock &&
-        (left.backing_block != right.backing_block || left.offset + left.size != right.offset)) {
-        const auto right_begin = right.backing_block->begin() + right.offset;
-        const auto right_end = right_begin + right.size;
-
-        // Check if we can save work.
-        if (left.offset == 0 && left.size == left.backing_block->size()) {
-            // Fast case: left is an entire backing block.
-            left.backing_block->insert(left.backing_block->end(), right_begin, right_end);
-        } else {
-            // Slow case: make a new memory block for left and right.
-            const auto left_begin = left.backing_block->begin() + left.offset;
-            const auto left_end = left_begin + left.size;
-            const auto left_size = static_cast<std::size_t>(std::distance(left_begin, left_end));
-            const auto right_size = static_cast<std::size_t>(std::distance(right_begin, right_end));
-
-            auto new_memory = std::make_shared<PhysicalMemory>();
-            new_memory->reserve(left_size + right_size);
-            new_memory->insert(new_memory->end(), left_begin, left_end);
-            new_memory->insert(new_memory->end(), right_begin, right_end);
-
-            left.backing_block = std::move(new_memory);
-            left.offset = 0;
-        }
-
-        // Page table update is needed, because backing memory changed.
-        left.size += right.size;
-        UpdatePageTableForVMA(left);
-    } else {
-        // Just update the size.
-        left.size += right.size;
-    }
-}
-
 void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
     switch (vma.type) {
     case VMAType::Free:
@@ -959,84 +778,6 @@ VMManager::CheckResults VMManager::CheckRangeState(VAddr address, u64 size, Memo
         std::make_tuple(initial_state, initial_permissions, initial_attributes & ~ignore_mask));
 }
 
-ResultVal<std::size_t> VMManager::SizeOfAllocatedVMAsInRange(VAddr address,
-                                                             std::size_t size) const {
-    const VAddr end_addr = address + size;
-    const VAddr last_addr = end_addr - 1;
-    std::size_t mapped_size = 0;
-
-    VAddr cur_addr = address;
-    auto iter = FindVMA(cur_addr);
-    ASSERT(iter != vma_map.end());
-
-    while (true) {
-        const auto& vma = iter->second;
-        const VAddr vma_start = vma.base;
-        const VAddr vma_end = vma_start + vma.size;
-        const VAddr vma_last = vma_end - 1;
-
-        // Add size if relevant.
-        if (vma.state != MemoryState::Unmapped) {
-            mapped_size += std::min(end_addr - cur_addr, vma_end - cur_addr);
-        }
-
-        // Break once we hit the end of the range.
-        if (last_addr <= vma_last) {
-            break;
-        }
-
-        // Advance to the next block.
-        cur_addr = vma_end;
-        iter = std::next(iter);
-        ASSERT(iter != vma_map.end());
-    }
-
-    return MakeResult(mapped_size);
-}
-
-ResultVal<std::size_t> VMManager::SizeOfUnmappablePhysicalMemoryInRange(VAddr address,
-                                                                        std::size_t size) const {
-    const VAddr end_addr = address + size;
-    const VAddr last_addr = end_addr - 1;
-    std::size_t mapped_size = 0;
-
-    VAddr cur_addr = address;
-    auto iter = FindVMA(cur_addr);
-    ASSERT(iter != vma_map.end());
-
-    while (true) {
-        const auto& vma = iter->second;
-        const auto vma_start = vma.base;
-        const auto vma_end = vma_start + vma.size;
-        const auto vma_last = vma_end - 1;
-        const auto state = vma.state;
-        const auto attr = vma.attribute;
-
-        // Memory within region must be free or mapped heap.
-        if (!((state == MemoryState::Heap && attr == MemoryAttribute::None) ||
-              (state == MemoryState::Unmapped))) {
-            return ERR_INVALID_ADDRESS_STATE;
-        }
-
-        // Add size if relevant.
-        if (state != MemoryState::Unmapped) {
-            mapped_size += std::min(end_addr - cur_addr, vma_end - cur_addr);
-        }
-
-        // Break once we hit the end of the range.
-        if (last_addr <= vma_last) {
-            break;
-        }
-
-        // Advance to the next block.
-        cur_addr = vma_end;
-        iter = std::next(iter);
-        ASSERT(iter != vma_map.end());
-    }
-
-    return MakeResult(mapped_size);
-}
-
 u64 VMManager::GetTotalPhysicalMemoryAvailable() const {
     LOG_WARNING(Kernel, "(STUBBED) called");
     return 0xF8000000;

src/core/hle/kernel/vm_manager.h

@@ -11,7 +11,6 @@
 #include "common/common_types.h"
 #include "common/memory_hook.h"
 #include "common/page_table.h"
-#include "core/hle/kernel/physical_memory.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
 
@@ -291,7 +290,7 @@ struct VirtualMemoryArea {
 
     // Settings for type = AllocatedMemoryBlock
     /// Memory block backing this VMA.
-    std::shared_ptr<PhysicalMemory> backing_block = nullptr;
+    std::shared_ptr<std::vector<u8>> backing_block = nullptr;
     /// Offset into the backing_memory the mapping starts from.
     std::size_t offset = 0;
 
@@ -349,9 +348,8 @@ public:
      * @param size Size of the mapping.
      * @param state MemoryState tag to attach to the VMA.
      */
-    ResultVal<VMAHandle> MapMemoryBlock(VAddr target, std::shared_ptr<PhysicalMemory> block,
-                                        std::size_t offset, u64 size, MemoryState state,
-                                        VMAPermission perm = VMAPermission::ReadWrite);
+    ResultVal<VMAHandle> MapMemoryBlock(VAddr target, std::shared_ptr<std::vector<u8>> block,
+                                        std::size_t offset, u64 size, MemoryState state);
 
     /**
      * Maps an unmanaged host memory pointer at a given address.
@@ -452,34 +450,6 @@ public:
     ///
     ResultVal<VAddr> SetHeapSize(u64 size);
 
-    /// Maps memory at a given address.
-    ///
-    /// @param target The virtual address to map memory at.
-    /// @param size   The amount of memory to map.
-    ///
-    /// @note The destination address must lie within the Map region.
-    ///
-    /// @note This function requires that SystemResourceSize be non-zero,
-    ///       however, this is just because if it were not then the
-    ///       resulting page tables could be exploited on hardware by
-    ///       a malicious program. SystemResource usage does not need
-    ///       to be explicitly checked or updated here.
-    ResultCode MapPhysicalMemory(VAddr target, u64 size);
-
-    /// Unmaps memory at a given address.
-    ///
-    /// @param target The virtual address to unmap memory at.
-    /// @param size   The amount of memory to unmap.
-    ///
-    /// @note The destination address must lie within the Map region.
-    ///
-    /// @note This function requires that SystemResourceSize be non-zero,
-    ///       however, this is just because if it were not then the
-    ///       resulting page tables could be exploited on hardware by
-    ///       a malicious program. SystemResource usage does not need
-    ///       to be explicitly checked or updated here.
-    ResultCode UnmapPhysicalMemory(VAddr target, u64 size);
-
     /// Maps a region of memory as code memory.
     ///
     /// @param dst_address The base address of the region to create the aliasing memory region.
@@ -548,7 +518,7 @@ public:
      * Scans all VMAs and updates the page table range of any that use the given vector as backing
      * memory. This should be called after any operation that causes reallocation of the vector.
      */
-    void RefreshMemoryBlockMappings(const PhysicalMemory* block);
+    void RefreshMemoryBlockMappings(const std::vector<u8>* block);
 
     /// Dumps the address space layout to the log, for debugging
     void LogLayout() const;
@@ -687,11 +657,6 @@ private:
      */
     VMAIter MergeAdjacent(VMAIter vma);
 
-    /**
-     * Merges two adjacent VMAs.
-     */
-    void MergeAdjacentVMA(VirtualMemoryArea& left, const VirtualMemoryArea& right);
-
     /// Updates the pages corresponding to this VMA so they match the VMA's attributes.
     void UpdatePageTableForVMA(const VirtualMemoryArea& vma);
 
@@ -736,13 +701,6 @@ private:
                                  MemoryAttribute attribute_mask, MemoryAttribute attribute,
                                  MemoryAttribute ignore_mask) const;
 
-    /// Gets the amount of memory currently mapped (state != Unmapped) in a range.
-    ResultVal<std::size_t> SizeOfAllocatedVMAsInRange(VAddr address, std::size_t size) const;
-
-    /// Gets the amount of memory unmappable by UnmapPhysicalMemory in a range.
-    ResultVal<std::size_t> SizeOfUnmappablePhysicalMemoryInRange(VAddr address,
-                                                                 std::size_t size) const;
-
     /**
      * A map covering the entirety of the managed address space, keyed by the `base` field of each
      * VMA. It must always be modified by splitting or merging VMAs, so that the invariant
@@ -778,17 +736,12 @@ private:
     // the entire virtual address space extents that bound the allocations, including any holes.
     // This makes deallocation and reallocation of holes fast and keeps process memory contiguous
     // in the emulator address space, allowing Memory::GetPointer to be reasonably safe.
-    std::shared_ptr<PhysicalMemory> heap_memory;
+    std::shared_ptr<std::vector<u8>> heap_memory;
 
     // The end of the currently allocated heap. This is not an inclusive
     // end of the range. This is essentially 'base_address + current_size'.
     VAddr heap_end = 0;
 
-    // The current amount of memory mapped via MapPhysicalMemory.
-    // This is used here (and in Nintendo's kernel) only for debugging, and does not impact
-    // any behavior.
-    u64 physical_memory_mapped = 0;
-
     Core::System& system;
 };
 } // namespace Kernel

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

@@ -266,8 +266,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {65, nullptr, "ReportUserIsActive"},
         {66, nullptr, "GetCurrentIlluminance"},
         {67, nullptr, "IsIlluminanceAvailable"},
-        {68, &ISelfController::SetAutoSleepDisabled, "SetAutoSleepDisabled"},
-        {69, &ISelfController::IsAutoSleepDisabled, "IsAutoSleepDisabled"},
+        {68, nullptr, "SetAutoSleepDisabled"},
+        {69, nullptr, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
         {71, nullptr, "GetCurrentIlluminanceEx"},
         {80, nullptr, "SetWirelessPriorityMode"},
@@ -454,34 +454,6 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
     rb.Push<u32>(idle_time_detection_extension);
 }
 
-void ISelfController::SetAutoSleepDisabled(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    is_auto_sleep_disabled = rp.Pop<bool>();
-
-    // On the system itself, if the previous state of is_auto_sleep_disabled
-    // differed from the current value passed in, it'd signify the internal
-    // window manager to update (and also increment some statistics like update counts)
-    //
-    // It'd also indicate this change to an idle handling context.
-    //
-    // However, given we're emulating this behavior, most of this can be ignored
-    // and it's sufficient to simply set the member variable for querying via
-    // IsAutoSleepDisabled().
-
-    LOG_DEBUG(Service_AM, "called. is_auto_sleep_disabled={}", is_auto_sleep_disabled);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void ISelfController::IsAutoSleepDisabled(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called.");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(is_auto_sleep_disabled);
-}
-
 void ISelfController::GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called.");
 

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

@@ -133,8 +133,6 @@ private:
     void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);
     void SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
     void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
-    void SetAutoSleepDisabled(Kernel::HLERequestContext& ctx);
-    void IsAutoSleepDisabled(Kernel::HLERequestContext& ctx);
     void GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx);
     void GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequestContext& ctx);
 
@@ -144,7 +142,6 @@ private:
 
     u32 idle_time_detection_extension = 0;
     u64 num_fatal_sections_entered = 0;
-    bool is_auto_sleep_disabled = false;
 };
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {

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

@@ -19,16 +19,16 @@
 
 namespace Service::Audio {
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<AudCtl>()->InstallAsService(service_manager);
     std::make_shared<AudOutA>()->InstallAsService(service_manager);
-    std::make_shared<AudOutU>(system)->InstallAsService(service_manager);
+    std::make_shared<AudOutU>()->InstallAsService(service_manager);
     std::make_shared<AudInA>()->InstallAsService(service_manager);
     std::make_shared<AudInU>()->InstallAsService(service_manager);
     std::make_shared<AudRecA>()->InstallAsService(service_manager);
     std::make_shared<AudRecU>()->InstallAsService(service_manager);
     std::make_shared<AudRenA>()->InstallAsService(service_manager);
-    std::make_shared<AudRenU>(system)->InstallAsService(service_manager);
+    std::make_shared<AudRenU>()->InstallAsService(service_manager);
     std::make_shared<CodecCtl>()->InstallAsService(service_manager);
     std::make_shared<HwOpus>()->InstallAsService(service_manager);
 

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

@@ -4,10 +4,6 @@
 
 #pragma once
 
-namespace Core {
-class System;
-}
-
 namespace Service::SM {
 class ServiceManager;
 }
@@ -15,6 +11,6 @@ class ServiceManager;
 namespace Service::Audio {
 
 /// Registers all Audio services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);
 
 } // namespace Service::Audio

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

@@ -40,8 +40,8 @@ enum class AudioState : u32 {
 
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
-    IAudioOut(Core::System& system, AudoutParams audio_params, AudioCore::AudioOut& audio_core,
-              std::string&& device_name, std::string&& unique_name)
+    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core, std::string&& device_name,
+              std::string&& unique_name)
         : ServiceFramework("IAudioOut"), audio_core(audio_core),
           device_name(std::move(device_name)), audio_params(audio_params) {
         // clang-format off
@@ -65,6 +65,7 @@ public:
         RegisterHandlers(functions);
 
         // This is the event handle used to check if the audio buffer was released
+        auto& system = Core::System::GetInstance();
         buffer_event = Kernel::WritableEvent::CreateEventPair(
             system.Kernel(), Kernel::ResetType::Manual, "IAudioOutBufferReleased");
 
@@ -211,22 +212,6 @@ private:
     Kernel::EventPair buffer_event;
 };
 
-AudOutU::AudOutU(Core::System& system_) : ServiceFramework("audout:u"), system{system_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, &AudOutU::ListAudioOutsImpl, "ListAudioOuts"},
-        {1, &AudOutU::OpenAudioOutImpl, "OpenAudioOut"},
-        {2, &AudOutU::ListAudioOutsImpl, "ListAudioOutsAuto"},
-        {3, &AudOutU::OpenAudioOutImpl, "OpenAudioOutAuto"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-    audio_core = std::make_unique<AudioCore::AudioOut>();
-}
-
-AudOutU::~AudOutU() = default;
-
 void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Audio, "called");
 
@@ -263,7 +248,7 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
 
     std::string unique_name{fmt::format("{}-{}", device_name, audio_out_interfaces.size())};
     auto audio_out_interface = std::make_shared<IAudioOut>(
-        system, params, *audio_core, std::move(device_name), std::move(unique_name));
+        params, *audio_core, std::move(device_name), std::move(unique_name));
 
     IPC::ResponseBuilder rb{ctx, 6, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -271,9 +256,20 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     rb.Push<u32>(params.channel_count);
     rb.Push<u32>(static_cast<u32>(AudioCore::Codec::PcmFormat::Int16));
     rb.Push<u32>(static_cast<u32>(AudioState::Stopped));
-    rb.PushIpcInterface<IAudioOut>(audio_out_interface);
+    rb.PushIpcInterface<Audio::IAudioOut>(audio_out_interface);
 
     audio_out_interfaces.push_back(std::move(audio_out_interface));
 }
 
+AudOutU::AudOutU() : ServiceFramework("audout:u") {
+    static const FunctionInfo functions[] = {{0, &AudOutU::ListAudioOutsImpl, "ListAudioOuts"},
+                                             {1, &AudOutU::OpenAudioOutImpl, "OpenAudioOut"},
+                                             {2, &AudOutU::ListAudioOutsImpl, "ListAudioOutsAuto"},
+                                             {3, &AudOutU::OpenAudioOutImpl, "OpenAudioOutAuto"}};
+    RegisterHandlers(functions);
+    audio_core = std::make_unique<AudioCore::AudioOut>();
+}
+
+AudOutU::~AudOutU() = default;
+
 } // namespace Service::Audio

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

@@ -11,10 +11,6 @@ namespace AudioCore {
 class AudioOut;
 }
 
-namespace Core {
-class System;
-}
-
 namespace Kernel {
 class HLERequestContext;
 }
@@ -25,17 +21,15 @@ class IAudioOut;
 
 class AudOutU final : public ServiceFramework<AudOutU> {
 public:
-    explicit AudOutU(Core::System& system_);
+    AudOutU();
     ~AudOutU() override;
 
 private:
-    void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
-    void OpenAudioOutImpl(Kernel::HLERequestContext& ctx);
-
     std::vector<std::shared_ptr<IAudioOut>> audio_out_interfaces;
     std::unique_ptr<AudioCore::AudioOut> audio_core;
 
-    Core::System& system;
+    void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
+    void OpenAudioOutImpl(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Audio

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

@@ -5,7 +5,6 @@
 #include <algorithm>
 #include <array>
 #include <memory>
-#include <string_view>
 
 #include "audio_core/audio_renderer.h"
 #include "common/alignment.h"
@@ -26,8 +25,7 @@ namespace Service::Audio {
 
 class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
-    explicit IAudioRenderer(Core::System& system, AudioCore::AudioRendererParameter audren_params,
-                            const std::size_t instance_number)
+    explicit IAudioRenderer(AudioCore::AudioRendererParameter audren_params)
         : ServiceFramework("IAudioRenderer") {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -47,10 +45,11 @@ public:
         // clang-format on
         RegisterHandlers(functions);
 
+        auto& system = Core::System::GetInstance();
         system_event = Kernel::WritableEvent::CreateEventPair(
             system.Kernel(), Kernel::ResetType::Manual, "IAudioRenderer:SystemEvent");
-        renderer = std::make_unique<AudioCore::AudioRenderer>(
-            system.CoreTiming(), audren_params, system_event.writable, instance_number);
+        renderer = std::make_unique<AudioCore::AudioRenderer>(system.CoreTiming(), audren_params,
+                                                              system_event.writable);
     }
 
 private:
@@ -160,8 +159,7 @@ private:
 
 class IAudioDevice final : public ServiceFramework<IAudioDevice> {
 public:
-    explicit IAudioDevice(Core::System& system, u32_le revision_num)
-        : ServiceFramework("IAudioDevice"), revision{revision_num} {
+    IAudioDevice() : ServiceFramework("IAudioDevice") {
         static const FunctionInfo functions[] = {
             {0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
             {1, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolume"},
@@ -179,7 +177,7 @@ public:
         };
         RegisterHandlers(functions);
 
-        auto& kernel = system.Kernel();
+        auto& kernel = Core::System::GetInstance().Kernel();
         buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
                                                               "IAudioOutBufferReleasedEvent");
 
@@ -190,47 +188,15 @@ public:
     }
 
 private:
-    using AudioDeviceName = std::array<char, 256>;
-    static constexpr std::array<std::string_view, 4> audio_device_names{{
-        "AudioStereoJackOutput",
-        "AudioBuiltInSpeakerOutput",
-        "AudioTvOutput",
-        "AudioUsbDeviceOutput",
-    }};
-    enum class DeviceType {
-        AHUBHeadphones,
-        AHUBSpeakers,
-        HDA,
-        USBOutput,
-    };
-
     void ListAudioDeviceName(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Audio, "called");
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        const bool usb_output_supported =
-            IsFeatureSupported(AudioFeatures::AudioUSBDeviceOutput, revision);
-        const std::size_t count = ctx.GetWriteBufferSize() / sizeof(AudioDeviceName);
-
-        std::vector<AudioDeviceName> name_buffer;
-        name_buffer.reserve(audio_device_names.size());
-
-        for (std::size_t i = 0; i < count && i < audio_device_names.size(); i++) {
-            const auto type = static_cast<DeviceType>(i);
-
-            if (!usb_output_supported && type == DeviceType::USBOutput) {
-                continue;
-            }
-
-            const auto& device_name = audio_device_names[i];
-            auto& entry = name_buffer.emplace_back();
-            device_name.copy(entry.data(), device_name.size());
-        }
-
-        ctx.WriteBuffer(name_buffer);
+        constexpr std::array<char, 15> audio_interface{{"AudioInterface"}};
+        ctx.WriteBuffer(audio_interface);
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u32>(name_buffer.size()));
+        rb.Push<u32>(1);
     }
 
     void SetAudioDeviceOutputVolume(Kernel::HLERequestContext& ctx) {
@@ -249,16 +215,12 @@ private:
     void GetActiveAudioDeviceName(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
-        // Currently set to always be TV audio output.
-        const auto& device_name = audio_device_names[2];
+        constexpr std::array<char, 12> audio_interface{{"AudioDevice"}};
+        ctx.WriteBuffer(audio_interface);
 
-        AudioDeviceName out_device_name{};
-        device_name.copy(out_device_name.data(), device_name.size());
-
-        ctx.WriteBuffer(out_device_name);
-
-        IPC::ResponseBuilder rb{ctx, 2};
+        IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(1);
     }
 
     void QueryAudioDeviceSystemEvent(Kernel::HLERequestContext& ctx) {
@@ -287,13 +249,12 @@ private:
         rb.PushCopyObjects(audio_output_device_switch_event.readable);
     }
 
-    u32_le revision = 0;
     Kernel::EventPair buffer_event;
     Kernel::EventPair audio_output_device_switch_event;
 
 }; // namespace Audio
 
-AudRenU::AudRenU(Core::System& system_) : ServiceFramework("audren:u"), system{system_} {
+AudRenU::AudRenU() : ServiceFramework("audren:u") {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &AudRenU::OpenAudioRenderer, "OpenAudioRenderer"},
@@ -366,7 +327,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     };
 
     // Calculates the portion of the size related to the mix data (and the sorting thereof).
-    const auto calculate_mix_info_size = [](const AudioCore::AudioRendererParameter& params) {
+    const auto calculate_mix_info_size = [this](const AudioCore::AudioRendererParameter& params) {
         // The size of the mixing info data structure.
         constexpr u64 mix_info_size = 0x940;
 
@@ -438,7 +399,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
 
     // Calculates the part of the size related to the splitter context.
     const auto calculate_splitter_context_size =
-        [](const AudioCore::AudioRendererParameter& params) -> u64 {
+        [this](const AudioCore::AudioRendererParameter& params) -> u64 {
         if (!IsFeatureSupported(AudioFeatures::Splitter, params.revision)) {
             return 0;
         }
@@ -485,7 +446,7 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     };
 
     // Calculates the part of the size related to performance statistics.
-    const auto calculate_perf_size = [](const AudioCore::AudioRendererParameter& params) {
+    const auto calculate_perf_size = [this](const AudioCore::AudioRendererParameter& params) {
         // Extra size value appended to the end of the calculation.
         constexpr u64 appended = 128;
 
@@ -512,76 +473,78 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
     };
 
     // Calculates the part of the size that relates to the audio command buffer.
-    const auto calculate_command_buffer_size = [](const AudioCore::AudioRendererParameter& params) {
-        constexpr u64 alignment = (buffer_alignment_size - 1) * 2;
+    const auto calculate_command_buffer_size =
+        [this](const AudioCore::AudioRendererParameter& params) {
+            constexpr u64 alignment = (buffer_alignment_size - 1) * 2;
 
-        if (!IsFeatureSupported(AudioFeatures::VariadicCommandBuffer, params.revision)) {
-            constexpr u64 command_buffer_size = 0x18000;
+            if (!IsFeatureSupported(AudioFeatures::VariadicCommandBuffer, params.revision)) {
+                constexpr u64 command_buffer_size = 0x18000;
 
-            return command_buffer_size + alignment;
-        }
+                return command_buffer_size + alignment;
+            }
 
-        // When the variadic command buffer is supported, this means
-        // the command generator for the audio renderer can issue commands
-        // that are (as one would expect), variable in size. So what we need to do
-        // is determine the maximum possible size for a few command data structures
-        // then multiply them by the amount of present commands indicated by the given
-        // respective audio parameters.
+            // When the variadic command buffer is supported, this means
+            // the command generator for the audio renderer can issue commands
+            // that are (as one would expect), variable in size. So what we need to do
+            // is determine the maximum possible size for a few command data structures
+            // then multiply them by the amount of present commands indicated by the given
+            // respective audio parameters.
 
-        constexpr u64 max_biquad_filters = 2;
-        constexpr u64 max_mix_buffers = 24;
+            constexpr u64 max_biquad_filters = 2;
+            constexpr u64 max_mix_buffers = 24;
 
-        constexpr u64 biquad_filter_command_size = 0x2C;
+            constexpr u64 biquad_filter_command_size = 0x2C;
 
-        constexpr u64 depop_mix_command_size = 0x24;
-        constexpr u64 depop_setup_command_size = 0x50;
+            constexpr u64 depop_mix_command_size = 0x24;
+            constexpr u64 depop_setup_command_size = 0x50;
 
-        constexpr u64 effect_command_max_size = 0x540;
+            constexpr u64 effect_command_max_size = 0x540;
 
-        constexpr u64 mix_command_size = 0x1C;
-        constexpr u64 mix_ramp_command_size = 0x24;
-        constexpr u64 mix_ramp_grouped_command_size = 0x13C;
+            constexpr u64 mix_command_size = 0x1C;
+            constexpr u64 mix_ramp_command_size = 0x24;
+            constexpr u64 mix_ramp_grouped_command_size = 0x13C;
 
-        constexpr u64 perf_command_size = 0x28;
+            constexpr u64 perf_command_size = 0x28;
 
-        constexpr u64 sink_command_size = 0x130;
+            constexpr u64 sink_command_size = 0x130;
 
-        constexpr u64 submix_command_max_size =
-            depop_mix_command_size + (mix_command_size * max_mix_buffers) * max_mix_buffers;
+            constexpr u64 submix_command_max_size =
+                depop_mix_command_size + (mix_command_size * max_mix_buffers) * max_mix_buffers;
 
-        constexpr u64 volume_command_size = 0x1C;
-        constexpr u64 volume_ramp_command_size = 0x20;
+            constexpr u64 volume_command_size = 0x1C;
+            constexpr u64 volume_ramp_command_size = 0x20;
 
-        constexpr u64 voice_biquad_filter_command_size =
-            biquad_filter_command_size * max_biquad_filters;
-        constexpr u64 voice_data_command_size = 0x9C;
-        const u64 voice_command_max_size =
-            (params.splitter_count * depop_setup_command_size) +
-            (voice_data_command_size + voice_biquad_filter_command_size + volume_ramp_command_size +
-             mix_ramp_grouped_command_size);
+            constexpr u64 voice_biquad_filter_command_size =
+                biquad_filter_command_size * max_biquad_filters;
+            constexpr u64 voice_data_command_size = 0x9C;
+            const u64 voice_command_max_size =
+                (params.splitter_count * depop_setup_command_size) +
+                (voice_data_command_size + voice_biquad_filter_command_size +
+                 volume_ramp_command_size + mix_ramp_grouped_command_size);
 
-        // Now calculate the individual elements that comprise the size and add them together.
-        const u64 effect_commands_size = params.effect_count * effect_command_max_size;
+            // Now calculate the individual elements that comprise the size and add them together.
+            const u64 effect_commands_size = params.effect_count * effect_command_max_size;
 
-        const u64 final_mix_commands_size =
-            depop_mix_command_size + volume_command_size * max_mix_buffers;
+            const u64 final_mix_commands_size =
+                depop_mix_command_size + volume_command_size * max_mix_buffers;
 
-        const u64 perf_commands_size =
-            perf_command_size * (CalculateNumPerformanceEntries(params) + max_perf_detail_entries);
+            const u64 perf_commands_size =
+                perf_command_size *
+                (CalculateNumPerformanceEntries(params) + max_perf_detail_entries);
 
-        const u64 sink_commands_size = params.sink_count * sink_command_size;
+            const u64 sink_commands_size = params.sink_count * sink_command_size;
 
-        const u64 splitter_commands_size =
-            params.num_splitter_send_channels * max_mix_buffers * mix_ramp_command_size;
+            const u64 splitter_commands_size =
+                params.num_splitter_send_channels * max_mix_buffers * mix_ramp_command_size;
 
-        const u64 submix_commands_size = params.submix_count * submix_command_max_size;
+            const u64 submix_commands_size = params.submix_count * submix_command_max_size;
 
-        const u64 voice_commands_size = params.voice_count * voice_command_max_size;
+            const u64 voice_commands_size = params.voice_count * voice_command_max_size;
 
-        return effect_commands_size + final_mix_commands_size + perf_commands_size +
-               sink_commands_size + splitter_commands_size + submix_commands_size +
-               voice_commands_size + alignment;
-    };
+            return effect_commands_size + final_mix_commands_size + perf_commands_size +
+                   sink_commands_size + splitter_commands_size + submix_commands_size +
+                   voice_commands_size + alignment;
+        };
 
     IPC::RequestParser rp{ctx};
     const auto params = rp.PopRaw<AudioCore::AudioRendererParameter>();
@@ -614,16 +577,12 @@ void AudRenU::GetAudioRendererWorkBufferSize(Kernel::HLERequestContext& ctx) {
 }
 
 void AudRenU::GetAudioDeviceService(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const u64 aruid = rp.Pop<u64>();
+    LOG_DEBUG(Service_Audio, "called");
 
-    LOG_DEBUG(Service_Audio, "called. aruid={:016X}", aruid);
-
-    // Revisionless variant of GetAudioDeviceServiceWithRevisionInfo that
-    // always assumes the initial release revision (REV1).
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IAudioDevice>(system, Common::MakeMagic('R', 'E', 'V', '1'));
+    rb.PushIpcInterface<Audio::IAudioDevice>();
 }
 
 void AudRenU::OpenAudioRendererAuto(Kernel::HLERequestContext& ctx) {
@@ -633,19 +592,13 @@ void AudRenU::OpenAudioRendererAuto(Kernel::HLERequestContext& ctx) {
 }
 
 void AudRenU::GetAudioDeviceServiceWithRevisionInfo(Kernel::HLERequestContext& ctx) {
-    struct Parameters {
-        u32 revision;
-        u64 aruid;
-    };
-
-    IPC::RequestParser rp{ctx};
-    const auto [revision, aruid] = rp.PopRaw<Parameters>();
-
-    LOG_DEBUG(Service_Audio, "called. revision={:08X}, aruid={:016X}", revision, aruid);
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IAudioDevice>(system, revision);
+    rb.PushIpcInterface<Audio::IAudioDevice>(); // TODO(ogniK): Figure out what is different
+                                                // based on the current revision
 }
 
 void AudRenU::OpenAudioRendererImpl(Kernel::HLERequestContext& ctx) {
@@ -654,16 +607,14 @@ void AudRenU::OpenAudioRendererImpl(Kernel::HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IAudioRenderer>(system, params, audren_instance_count++);
+    rb.PushIpcInterface<IAudioRenderer>(params);
 }
 
-bool IsFeatureSupported(AudioFeatures feature, u32_le revision) {
+bool AudRenU::IsFeatureSupported(AudioFeatures feature, u32_le revision) const {
     // Byte swap
     const u32_be version_num = revision - Common::MakeMagic('R', 'E', 'V', '0');
 
     switch (feature) {
-    case AudioFeatures::AudioUSBDeviceOutput:
-        return version_num >= 4U;
     case AudioFeatures::Splitter:
         return version_num >= 2U;
     case AudioFeatures::PerformanceMetricsVersion2:

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

@@ -6,10 +6,6 @@
 
 #include "core/hle/service/service.h"
 
-namespace Core {
-class System;
-}
-
 namespace Kernel {
 class HLERequestContext;
 }
@@ -18,7 +14,7 @@ namespace Service::Audio {
 
 class AudRenU final : public ServiceFramework<AudRenU> {
 public:
-    explicit AudRenU(Core::System& system_);
+    explicit AudRenU();
     ~AudRenU() override;
 
 private:
@@ -30,19 +26,13 @@ private:
 
     void OpenAudioRendererImpl(Kernel::HLERequestContext& ctx);
 
-    std::size_t audren_instance_count = 0;
-    Core::System& system;
-};
+    enum class AudioFeatures : u32 {
+        Splitter,
+        PerformanceMetricsVersion2,
+        VariadicCommandBuffer,
+    };
 
-// Describes a particular audio feature that may be supported in a particular revision.
-enum class AudioFeatures : u32 {
-    AudioUSBDeviceOutput,
-    Splitter,
-    PerformanceMetricsVersion2,
-    VariadicCommandBuffer,
+    bool IsFeatureSupported(AudioFeatures feature, u32_le revision) const;
 };
 
-// Tests if a particular audio feature is supported with a given audio revision.
-bool IsFeatureSupported(AudioFeatures feature, u32_le revision);
-
 } // namespace Service::Audio

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

@@ -22,7 +22,7 @@ public:
             {0, nullptr, "GetCompletionEvent"},
             {1, nullptr, "Cancel"},
             {10100, nullptr, "GetFriendListIds"},
-            {10101, &IFriendService::GetFriendList, "GetFriendList"},
+            {10101, nullptr, "GetFriendList"},
             {10102, nullptr, "UpdateFriendInfo"},
             {10110, nullptr, "GetFriendProfileImage"},
             {10200, nullptr, "SendFriendRequestForApplication"},
@@ -99,23 +99,6 @@ public:
     }
 
 private:
-    enum class PresenceFilter : u32 {
-        None = 0,
-        Online = 1,
-        OnlinePlay = 2,
-        OnlineOrOnlinePlay = 3,
-    };
-
-    struct SizedFriendFilter {
-        PresenceFilter presence;
-        u8 is_favorite;
-        u8 same_app;
-        u8 same_app_played;
-        u8 arbitary_app_played;
-        u64 group_id;
-    };
-    static_assert(sizeof(SizedFriendFilter) == 0x10, "SizedFriendFilter is an invalid size");
-
     void DeclareCloseOnlinePlaySession(Kernel::HLERequestContext& ctx) {
         // Stub used by Splatoon 2
         LOG_WARNING(Service_ACC, "(STUBBED) called");
@@ -129,22 +112,6 @@ private:
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
     }
-
-    void GetFriendList(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto friend_offset = rp.Pop<u32>();
-        const auto uuid = rp.PopRaw<Common::UUID>();
-        [[maybe_unused]] const auto filter = rp.PopRaw<SizedFriendFilter>();
-        const auto pid = rp.Pop<u64>();
-        LOG_WARNING(Service_ACC, "(STUBBED) called, offset={}, uuid={}, pid={}", friend_offset,
-                    uuid.Format(), pid);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-
-        rb.Push<u32>(0); // Friend count
-        // TODO(ogniK): Return a buffer of u64s which are the "NetworkServiceAccountId"
-    }
 };
 
 class INotificationService final : public ServiceFramework<INotificationService> {

src/core/hle/service/ldr/ldr.cpp

@@ -345,16 +345,14 @@ public:
             vm_manager
                 .MirrorMemory(*map_address, nro_address, nro_size, Kernel::MemoryState::ModuleCode)
                 .IsSuccess());
-        ASSERT(vm_manager.ReprotectRange(nro_address, nro_size, Kernel::VMAPermission::None)
-                   .IsSuccess());
+        ASSERT(vm_manager.UnmapRange(nro_address, nro_size).IsSuccess());
 
         if (bss_size > 0) {
             ASSERT(vm_manager
                        .MirrorMemory(*map_address + nro_size, bss_address, bss_size,
                                      Kernel::MemoryState::ModuleCode)
                        .IsSuccess());
-            ASSERT(vm_manager.ReprotectRange(bss_address, bss_size, Kernel::VMAPermission::None)
-                       .IsSuccess());
+            ASSERT(vm_manager.UnmapRange(bss_address, bss_size).IsSuccess());
         }
 
         vm_manager.ReprotectRange(*map_address, header.text_size,
@@ -366,8 +364,7 @@ public:
 
         Core::System::GetInstance().InvalidateCpuInstructionCaches();
 
-        nro.insert_or_assign(*map_address,
-                             NROInfo{hash, nro_address, nro_size, bss_address, bss_size});
+        nro.insert_or_assign(*map_address, NROInfo{hash, nro_size + bss_size});
 
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
@@ -412,23 +409,9 @@ public:
         }
 
         auto& vm_manager = Core::CurrentProcess()->VMManager();
-        const auto& nro_info = iter->second;
+        const auto& nro_size = iter->second.size;
 
-        // Unmap the mirrored memory
-        ASSERT(
-            vm_manager.UnmapRange(nro_address, nro_info.nro_size + nro_info.bss_size).IsSuccess());
-
-        // Reprotect the source memory
-        ASSERT(vm_manager
-                   .ReprotectRange(nro_info.nro_address, nro_info.nro_size,
-                                   Kernel::VMAPermission::ReadWrite)
-                   .IsSuccess());
-        if (nro_info.bss_size > 0) {
-            ASSERT(vm_manager
-                       .ReprotectRange(nro_info.bss_address, nro_info.bss_size,
-                                       Kernel::VMAPermission::ReadWrite)
-                       .IsSuccess());
-        }
+        ASSERT(vm_manager.UnmapRange(nro_address, nro_size).IsSuccess());
 
         Core::System::GetInstance().InvalidateCpuInstructionCaches();
 
@@ -490,10 +473,7 @@ private:
 
     struct NROInfo {
         SHA256Hash hash;
-        VAddr nro_address;
-        u64 nro_size;
-        VAddr bss_address;
-        u64 bss_size;
+        u64 size;
     };
 
     bool initialized = false;

src/core/hle/service/mii/mii.cpp

@@ -48,7 +48,7 @@ public:
             {19, nullptr, "Export"},
             {20, nullptr, "IsBrokenDatabaseWithClearFlag"},
             {21, &IDatabaseService::GetIndex, "GetIndex"},
-            {22, &IDatabaseService::SetInterfaceVersion, "SetInterfaceVersion"},
+            {22, nullptr, "SetInterfaceVersion"},
             {23, nullptr, "Convert"},
         };
         // clang-format on
@@ -350,22 +350,8 @@ private:
         rb.Push(index);
     }
 
-    void SetInterfaceVersion(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        current_interface_version = rp.PopRaw<u32>();
-
-        LOG_DEBUG(Service_Mii, "called, interface_version={:08X}", current_interface_version);
-
-        UNIMPLEMENTED_IF(current_interface_version != 1);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
     MiiManager db;
 
-    u32 current_interface_version = 0;
-
     // Last read offsets of Get functions
     std::array<u32, 4> offsets{};
 };

src/core/hle/service/mii/mii_manager.cpp

@@ -175,6 +175,10 @@ MiiStoreData ConvertInfoToStoreData(const MiiInfo& info) {
 } // namespace
 
 std::ostream& operator<<(std::ostream& os, Source source) {
+    if (static_cast<std::size_t>(source) >= SOURCE_NAMES.size()) {
+        return os << "[UNKNOWN SOURCE]";
+    }
+
     os << SOURCE_NAMES.at(static_cast<std::size_t>(source));
     return os;
 }

src/core/hle/service/ns/pl_u.cpp

@@ -77,7 +77,7 @@ enum class LoadState : u32 {
     Done = 1,
 };
 
-static void DecryptSharedFont(const std::vector<u32>& input, Kernel::PhysicalMemory& output,
+static void DecryptSharedFont(const std::vector<u32>& input, std::vector<u8>& output,
                               std::size_t& offset) {
     ASSERT_MSG(offset + (input.size() * sizeof(u32)) < SHARED_FONT_MEM_SIZE,
                "Shared fonts exceeds 17mb!");
@@ -94,7 +94,7 @@ static void DecryptSharedFont(const std::vector<u32>& input, Kernel::PhysicalMem
     offset += transformed_font.size() * sizeof(u32);
 }
 
-static void EncryptSharedFont(const std::vector<u8>& input, Kernel::PhysicalMemory& output,
+static void EncryptSharedFont(const std::vector<u8>& input, std::vector<u8>& output,
                               std::size_t& offset) {
     ASSERT_MSG(offset + input.size() + 8 < SHARED_FONT_MEM_SIZE, "Shared fonts exceeds 17mb!");
     const u32 KEY = EXPECTED_MAGIC ^ EXPECTED_RESULT;
@@ -121,7 +121,7 @@ struct PL_U::Impl {
         return shared_font_regions.at(index);
     }
 
-    void BuildSharedFontsRawRegions(const Kernel::PhysicalMemory& input) {
+    void BuildSharedFontsRawRegions(const std::vector<u8>& input) {
         // As we can derive the xor key we can just populate the offsets
         // based on the shared memory dump
         unsigned cur_offset = 0;
@@ -144,7 +144,7 @@ struct PL_U::Impl {
     Kernel::SharedPtr<Kernel::SharedMemory> shared_font_mem;
 
     /// Backing memory for the shared font data
-    std::shared_ptr<Kernel::PhysicalMemory> shared_font;
+    std::shared_ptr<std::vector<u8>> shared_font;
 
     // Automatically populated based on shared_fonts dump or system archives.
     std::vector<FontRegion> shared_font_regions;
@@ -166,7 +166,7 @@ PL_U::PL_U() : ServiceFramework("pl:u"), impl{std::make_unique<Impl>()} {
     // Rebuild shared fonts from data ncas
     if (nand->HasEntry(static_cast<u64>(FontArchives::Standard),
                        FileSys::ContentRecordType::Data)) {
-        impl->shared_font = std::make_shared<Kernel::PhysicalMemory>(SHARED_FONT_MEM_SIZE);
+        impl->shared_font = std::make_shared<std::vector<u8>>(SHARED_FONT_MEM_SIZE);
         for (auto font : SHARED_FONTS) {
             const auto nca =
                 nand->GetEntry(static_cast<u64>(font.first), FileSys::ContentRecordType::Data);
@@ -207,7 +207,7 @@ PL_U::PL_U() : ServiceFramework("pl:u"), impl{std::make_unique<Impl>()} {
         }
 
     } else {
-        impl->shared_font = std::make_shared<Kernel::PhysicalMemory>(
+        impl->shared_font = std::make_shared<std::vector<u8>>(
             SHARED_FONT_MEM_SIZE); // Shared memory needs to always be allocated and a fixed size
 
         const std::string user_path = FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir);

src/core/hle/service/nvdrv/devices/nvdevice.h

@@ -8,11 +8,6 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/hle/service/nvdrv/nvdata.h"
-
-namespace Core {
-class System;
-}
 
 namespace Service::Nvidia::Devices {
 
@@ -20,7 +15,7 @@ namespace Service::Nvidia::Devices {
 /// implement the ioctl interface.
 class nvdevice {
 public:
-    explicit nvdevice(Core::System& system) : system{system} {};
+    nvdevice() = default;
     virtual ~nvdevice() = default;
     union Ioctl {
         u32_le raw;
@@ -38,11 +33,7 @@ public:
      * @param output A buffer where the output data will be written to.
      * @returns The result code of the ioctl.
      */
-    virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                      IoctlCtrl& ctrl) = 0;
-
-protected:
-    Core::System& system;
+    virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) = 0;
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -13,12 +13,10 @@
 
 namespace Service::Nvidia::Devices {
 
-nvdisp_disp0::nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
-    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
+nvdisp_disp0::nvdisp_disp0(std::shared_ptr<nvmap> nvmap_dev) : nvmap_dev(std::move(nvmap_dev)) {}
 nvdisp_disp0 ::~nvdisp_disp0() = default;
 
-u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                        IoctlCtrl& ctrl) {
+u32 nvdisp_disp0::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     UNIMPLEMENTED_MSG("Unimplemented ioctl");
     return 0;
 }
@@ -36,8 +34,9 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3
         addr,      offset,   width, height, stride, static_cast<PixelFormat>(format),
         transform, crop_rect};
 
-    system.GetPerfStats().EndGameFrame();
-    system.GPU().SwapBuffers(framebuffer);
+    auto& instance = Core::System::GetInstance();
+    instance.GetPerfStats().EndGameFrame();
+    instance.GPU().SwapBuffers(framebuffer);
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -17,11 +17,10 @@ class nvmap;
 
 class nvdisp_disp0 final : public nvdevice {
 public:
-    explicit nvdisp_disp0(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
+    explicit nvdisp_disp0(std::shared_ptr<nvmap> nvmap_dev);
     ~nvdisp_disp0() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
     /// Performs a screen flip, drawing the buffer pointed to by the handle.
     void flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u32 height, u32 stride,

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -22,12 +22,10 @@ enum {
 };
 }
 
-nvhost_as_gpu::nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
-    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
+nvhost_as_gpu::nvhost_as_gpu(std::shared_ptr<nvmap> nvmap_dev) : nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_as_gpu::~nvhost_as_gpu() = default;
 
-u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                         IoctlCtrl& ctrl) {
+u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
               command.raw, input.size(), output.size());
 
@@ -67,7 +65,7 @@ u32 nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>&
     LOG_DEBUG(Service_NVDRV, "called, pages={:X}, page_size={:X}, flags={:X}", params.pages,
               params.page_size, params.flags);
 
-    auto& gpu = system.GPU();
+    auto& gpu = Core::System::GetInstance().GPU();
     const u64 size{static_cast<u64>(params.pages) * static_cast<u64>(params.page_size)};
     if (params.flags & 1) {
         params.offset = gpu.MemoryManager().AllocateSpace(params.offset, size, 1);
@@ -87,7 +85,7 @@ u32 nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& output)
     std::vector<IoctlRemapEntry> entries(num_entries);
     std::memcpy(entries.data(), input.data(), input.size());
 
-    auto& gpu = system.GPU();
+    auto& gpu = Core::System::GetInstance().GPU();
     for (const auto& entry : entries) {
         LOG_WARNING(Service_NVDRV, "remap entry, offset=0x{:X} handle=0x{:X} pages=0x{:X}",
                     entry.offset, entry.nvmap_handle, entry.pages);
@@ -138,7 +136,7 @@ u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& ou
     // case to prevent unexpected behavior.
     ASSERT(object->id == params.nvmap_handle);
 
-    auto& gpu = system.GPU();
+    auto& gpu = Core::System::GetInstance().GPU();
 
     if (params.flags & 1) {
         params.offset = gpu.MemoryManager().MapBufferEx(object->addr, params.offset, object->size);
@@ -175,7 +173,8 @@ u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& ou
         return 0;
     }
 
-    params.offset = system.GPU().MemoryManager().UnmapBuffer(params.offset, itr->second.size);
+    params.offset = Core::System::GetInstance().GPU().MemoryManager().UnmapBuffer(params.offset,
+                                                                                  itr->second.size);
     buffer_mappings.erase(itr->second.offset);
 
     std::memcpy(output.data(), &params, output.size());

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h

@@ -17,11 +17,10 @@ class nvmap;
 
 class nvhost_as_gpu final : public nvdevice {
 public:
-    explicit nvhost_as_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
+    explicit nvhost_as_gpu(std::shared_ptr<nvmap> nvmap_dev);
     ~nvhost_as_gpu() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
     enum class IoctlCommand : u32_le {

src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -7,20 +7,14 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl.h"
-#include "video_core/gpu.h"
 
 namespace Service::Nvidia::Devices {
 
-nvhost_ctrl::nvhost_ctrl(Core::System& system, EventInterface& events_interface)
-    : nvdevice(system), events_interface{events_interface} {}
+nvhost_ctrl::nvhost_ctrl() = default;
 nvhost_ctrl::~nvhost_ctrl() = default;
 
-u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                       IoctlCtrl& ctrl) {
+u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
               command.raw, input.size(), output.size());
 
@@ -28,15 +22,11 @@ u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<
     case IoctlCommand::IocGetConfigCommand:
         return NvOsGetConfigU32(input, output);
     case IoctlCommand::IocCtrlEventWaitCommand:
-        return IocCtrlEventWait(input, output, false, ctrl);
+        return IocCtrlEventWait(input, output, false);
     case IoctlCommand::IocCtrlEventWaitAsyncCommand:
-        return IocCtrlEventWait(input, output, true, ctrl);
+        return IocCtrlEventWait(input, output, true);
     case IoctlCommand::IocCtrlEventRegisterCommand:
         return IocCtrlEventRegister(input, output);
-    case IoctlCommand::IocCtrlEventUnregisterCommand:
-        return IocCtrlEventUnregister(input, output);
-    case IoctlCommand::IocCtrlEventSignalCommand:
-        return IocCtrlEventSignal(input, output);
     }
     UNIMPLEMENTED_MSG("Unimplemented ioctl");
     return 0;
@@ -51,137 +41,23 @@ u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>&
 }
 
 u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output,
-                                  bool is_async, IoctlCtrl& ctrl) {
+                                  bool is_async) {
     IocCtrlEventWaitParams params{};
     std::memcpy(&params, input.data(), sizeof(params));
-    LOG_DEBUG(Service_NVDRV, "syncpt_id={}, threshold={}, timeout={}, is_async={}",
-              params.syncpt_id, params.threshold, params.timeout, is_async);
+    LOG_WARNING(Service_NVDRV,
+                "(STUBBED) called, syncpt_id={}, threshold={}, timeout={}, is_async={}",
+                params.syncpt_id, params.threshold, params.timeout, is_async);
 
-    if (params.syncpt_id >= MaxSyncPoints) {
-        return NvResult::BadParameter;
-    }
-
-    auto& gpu = system.GPU();
-    // This is mostly to take into account unimplemented features. As synced
-    // gpu is always synced.
-    if (!gpu.IsAsync()) {
-        return NvResult::Success;
-    }
-    auto lock = gpu.LockSync();
-    const u32 current_syncpoint_value = gpu.GetSyncpointValue(params.syncpt_id);
-    const s32 diff = current_syncpoint_value - params.threshold;
-    if (diff >= 0) {
-        params.value = current_syncpoint_value;
-        std::memcpy(output.data(), &params, sizeof(params));
-        return NvResult::Success;
-    }
-    const u32 target_value = current_syncpoint_value - diff;
-
-    if (!is_async) {
-        params.value = 0;
-    }
-
-    if (params.timeout == 0) {
-        std::memcpy(output.data(), &params, sizeof(params));
-        return NvResult::Timeout;
-    }
-
-    u32 event_id;
-    if (is_async) {
-        event_id = params.value & 0x00FF;
-        if (event_id >= MaxNvEvents) {
-            std::memcpy(output.data(), &params, sizeof(params));
-            return NvResult::BadParameter;
-        }
-    } else {
-        if (ctrl.fresh_call) {
-            const auto result = events_interface.GetFreeEvent();
-            if (result) {
-                event_id = *result;
-            } else {
-                LOG_CRITICAL(Service_NVDRV, "No Free Events available!");
-                event_id = params.value & 0x00FF;
-            }
-        } else {
-            event_id = ctrl.event_id;
-        }
-    }
-
-    EventState status = events_interface.status[event_id];
-    if (event_id < MaxNvEvents || status == EventState::Free || status == EventState::Registered) {
-        events_interface.SetEventStatus(event_id, EventState::Waiting);
-        events_interface.assigned_syncpt[event_id] = params.syncpt_id;
-        events_interface.assigned_value[event_id] = target_value;
-        if (is_async) {
-            params.value = params.syncpt_id << 4;
-        } else {
-            params.value = ((params.syncpt_id & 0xfff) << 16) | 0x10000000;
-        }
-        params.value |= event_id;
-        events_interface.events[event_id].writable->Clear();
-        gpu.RegisterSyncptInterrupt(params.syncpt_id, target_value);
-        if (!is_async && ctrl.fresh_call) {
-            ctrl.must_delay = true;
-            ctrl.timeout = params.timeout;
-            ctrl.event_id = event_id;
-            return NvResult::Timeout;
-        }
-        std::memcpy(output.data(), &params, sizeof(params));
-        return NvResult::Timeout;
-    }
+    // TODO(Subv): Implement actual syncpt waiting.
+    params.value = 0;
     std::memcpy(output.data(), &params, sizeof(params));
-    return NvResult::BadParameter;
+    return 0;
 }
 
 u32 nvhost_ctrl::IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output) {
-    IocCtrlEventRegisterParams params{};
-    std::memcpy(&params, input.data(), sizeof(params));
-    const u32 event_id = params.user_event_id & 0x00FF;
-    LOG_DEBUG(Service_NVDRV, " called, user_event_id: {:X}", event_id);
-    if (event_id >= MaxNvEvents) {
-        return NvResult::BadParameter;
-    }
-    if (events_interface.registered[event_id]) {
-        return NvResult::BadParameter;
-    }
-    events_interface.RegisterEvent(event_id);
-    return NvResult::Success;
-}
-
-u32 nvhost_ctrl::IocCtrlEventUnregister(const std::vector<u8>& input, std::vector<u8>& output) {
-    IocCtrlEventUnregisterParams params{};
-    std::memcpy(&params, input.data(), sizeof(params));
-    const u32 event_id = params.user_event_id & 0x00FF;
-    LOG_DEBUG(Service_NVDRV, " called, user_event_id: {:X}", event_id);
-    if (event_id >= MaxNvEvents) {
-        return NvResult::BadParameter;
-    }
-    if (!events_interface.registered[event_id]) {
-        return NvResult::BadParameter;
-    }
-    events_interface.UnregisterEvent(event_id);
-    return NvResult::Success;
-}
-
-u32 nvhost_ctrl::IocCtrlEventSignal(const std::vector<u8>& input, std::vector<u8>& output) {
-    IocCtrlEventSignalParams params{};
-    std::memcpy(&params, input.data(), sizeof(params));
-    // TODO(Blinkhawk): This is normally called when an NvEvents timeout on WaitSynchronization
-    // It is believed from RE to cancel the GPU Event. However, better research is required
-    u32 event_id = params.user_event_id & 0x00FF;
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called, user_event_id: {:X}", event_id);
-    if (event_id >= MaxNvEvents) {
-        return NvResult::BadParameter;
-    }
-    if (events_interface.status[event_id] == EventState::Waiting) {
-        auto& gpu = system.GPU();
-        if (gpu.CancelSyncptInterrupt(events_interface.assigned_syncpt[event_id],
-                                      events_interface.assigned_value[event_id])) {
-            events_interface.LiberateEvent(event_id);
-            events_interface.events[event_id].writable->Signal();
-        }
-    }
-    return NvResult::Success;
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    // TODO(bunnei): Implement this.
+    return 0;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -8,17 +8,15 @@
 #include <vector>
 #include "common/common_types.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
-#include "core/hle/service/nvdrv/nvdrv.h"
 
 namespace Service::Nvidia::Devices {
 
 class nvhost_ctrl final : public nvdevice {
 public:
-    explicit nvhost_ctrl(Core::System& system, EventInterface& events_interface);
+    nvhost_ctrl();
     ~nvhost_ctrl() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
     enum class IoctlCommand : u32_le {
@@ -134,16 +132,9 @@ private:
 
     u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
 
-    u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output, bool is_async,
-                         IoctlCtrl& ctrl);
+    u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output, bool is_async);
 
     u32 IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output);
-
-    u32 IocCtrlEventUnregister(const std::vector<u8>& input, std::vector<u8>& output);
-
-    u32 IocCtrlEventSignal(const std::vector<u8>& input, std::vector<u8>& output);
-
-    EventInterface& events_interface;
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp

@@ -12,11 +12,10 @@
 
 namespace Service::Nvidia::Devices {
 
-nvhost_ctrl_gpu::nvhost_ctrl_gpu(Core::System& system) : nvdevice(system) {}
+nvhost_ctrl_gpu::nvhost_ctrl_gpu() = default;
 nvhost_ctrl_gpu::~nvhost_ctrl_gpu() = default;
 
-u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                           IoctlCtrl& ctrl) {
+u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
               command.raw, input.size(), output.size());
 
@@ -186,7 +185,7 @@ u32 nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& o
 
     IoctlGetGpuTime params{};
     std::memcpy(&params, input.data(), input.size());
-    const auto ns = Core::Timing::CyclesToNs(system.CoreTiming().GetTicks());
+    const auto ns = Core::Timing::CyclesToNs(Core::System::GetInstance().CoreTiming().GetTicks());
     params.gpu_time = static_cast<u64_le>(ns.count());
     std::memcpy(output.data(), &params, output.size());
     return 0;

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h

@@ -13,11 +13,10 @@ namespace Service::Nvidia::Devices {
 
 class nvhost_ctrl_gpu final : public nvdevice {
 public:
-    explicit nvhost_ctrl_gpu(Core::System& system);
+    nvhost_ctrl_gpu();
     ~nvhost_ctrl_gpu() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
     enum class IoctlCommand : u32_le {

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -13,12 +13,10 @@
 
 namespace Service::Nvidia::Devices {
 
-nvhost_gpu::nvhost_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
-    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
+nvhost_gpu::nvhost_gpu(std::shared_ptr<nvmap> nvmap_dev) : nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_gpu::~nvhost_gpu() = default;
 
-u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                      IoctlCtrl& ctrl) {
+u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
               command.raw, input.size(), output.size());
 
@@ -121,10 +119,8 @@ u32 nvhost_gpu::AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& ou
                 params.num_entries, params.flags, params.unk0, params.unk1, params.unk2,
                 params.unk3);
 
-    auto& gpu = system.GPU();
-    params.fence_out.id = assigned_syncpoints;
-    params.fence_out.value = gpu.GetSyncpointValue(assigned_syncpoints);
-    assigned_syncpoints++;
+    params.fence_out.id = 0;
+    params.fence_out.value = 0;
     std::memcpy(output.data(), &params, output.size());
     return 0;
 }
@@ -147,7 +143,7 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
     IoctlSubmitGpfifo params{};
     std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, gpfifo={:X}, num_entries={:X}, flags={:X}",
-                params.address, params.num_entries, params.flags.raw);
+                params.address, params.num_entries, params.flags);
 
     ASSERT_MSG(input.size() == sizeof(IoctlSubmitGpfifo) +
                                    params.num_entries * sizeof(Tegra::CommandListHeader),
@@ -157,18 +153,10 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
     std::memcpy(entries.data(), &input[sizeof(IoctlSubmitGpfifo)],
                 params.num_entries * sizeof(Tegra::CommandListHeader));
 
-    UNIMPLEMENTED_IF(params.flags.add_wait.Value() != 0);
-    UNIMPLEMENTED_IF(params.flags.add_increment.Value() != 0);
-
-    auto& gpu = system.GPU();
-    u32 current_syncpoint_value = gpu.GetSyncpointValue(params.fence_out.id);
-    if (params.flags.increment.Value()) {
-        params.fence_out.value += current_syncpoint_value;
-    } else {
-        params.fence_out.value = current_syncpoint_value;
-    }
-    gpu.PushGPUEntries(std::move(entries));
+    Core::System::GetInstance().GPU().PushGPUEntries(std::move(entries));
 
+    params.fence_out.id = 0;
+    params.fence_out.value = 0;
     std::memcpy(output.data(), &params, sizeof(IoctlSubmitGpfifo));
     return 0;
 }
@@ -180,24 +168,16 @@ u32 nvhost_gpu::KickoffPB(const std::vector<u8>& input, std::vector<u8>& output)
     IoctlSubmitGpfifo params{};
     std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, gpfifo={:X}, num_entries={:X}, flags={:X}",
-                params.address, params.num_entries, params.flags.raw);
+                params.address, params.num_entries, params.flags);
 
     Tegra::CommandList entries(params.num_entries);
     Memory::ReadBlock(params.address, entries.data(),
                       params.num_entries * sizeof(Tegra::CommandListHeader));
 
-    UNIMPLEMENTED_IF(params.flags.add_wait.Value() != 0);
-    UNIMPLEMENTED_IF(params.flags.add_increment.Value() != 0);
-
-    auto& gpu = system.GPU();
-    u32 current_syncpoint_value = gpu.GetSyncpointValue(params.fence_out.id);
-    if (params.flags.increment.Value()) {
-        params.fence_out.value += current_syncpoint_value;
-    } else {
-        params.fence_out.value = current_syncpoint_value;
-    }
-    gpu.PushGPUEntries(std::move(entries));
+    Core::System::GetInstance().GPU().PushGPUEntries(std::move(entries));
 
+    params.fence_out.id = 0;
+    params.fence_out.value = 0;
     std::memcpy(output.data(), &params, output.size());
     return 0;
 }

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -10,7 +10,6 @@
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
-#include "core/hle/service/nvdrv/nvdata.h"
 
 namespace Service::Nvidia::Devices {
 
@@ -21,11 +20,10 @@ constexpr u32 NVGPU_IOCTL_CHANNEL_KICKOFF_PB(0x1b);
 
 class nvhost_gpu final : public nvdevice {
 public:
-    explicit nvhost_gpu(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
+    explicit nvhost_gpu(std::shared_ptr<nvmap> nvmap_dev);
     ~nvhost_gpu() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
     enum class IoctlCommand : u32_le {
@@ -115,7 +113,11 @@ private:
     static_assert(sizeof(IoctlGetErrorNotification) == 16,
                   "IoctlGetErrorNotification is incorrect size");
 
-    static_assert(sizeof(Fence) == 8, "Fence is incorrect size");
+    struct IoctlFence {
+        u32_le id;
+        u32_le value;
+    };
+    static_assert(sizeof(IoctlFence) == 8, "IoctlFence is incorrect size");
 
     struct IoctlAllocGpfifoEx {
         u32_le num_entries;
@@ -130,13 +132,13 @@ private:
     static_assert(sizeof(IoctlAllocGpfifoEx) == 32, "IoctlAllocGpfifoEx is incorrect size");
 
     struct IoctlAllocGpfifoEx2 {
-        u32_le num_entries; // in
-        u32_le flags;       // in
-        u32_le unk0;        // in (1 works)
-        Fence fence_out;    // out
-        u32_le unk1;        // in
-        u32_le unk2;        // in
-        u32_le unk3;        // in
+        u32_le num_entries;   // in
+        u32_le flags;         // in
+        u32_le unk0;          // in (1 works)
+        IoctlFence fence_out; // out
+        u32_le unk1;          // in
+        u32_le unk2;          // in
+        u32_le unk3;          // in
     };
     static_assert(sizeof(IoctlAllocGpfifoEx2) == 32, "IoctlAllocGpfifoEx2 is incorrect size");
 
@@ -151,16 +153,10 @@ private:
     struct IoctlSubmitGpfifo {
         u64_le address;     // pointer to gpfifo entry structs
         u32_le num_entries; // number of fence objects being submitted
-        union {
-            u32_le raw;
-            BitField<0, 1, u32_le> add_wait;      // append a wait sync_point to the list
-            BitField<1, 1, u32_le> add_increment; // append an increment to the list
-            BitField<2, 1, u32_le> new_hw_format; // Mostly ignored
-            BitField<8, 1, u32_le> increment;     // increment the returned fence
-        } flags;
-        Fence fence_out; // returned new fence object for others to wait on
+        u32_le flags;
+        IoctlFence fence_out; // returned new fence object for others to wait on
     };
-    static_assert(sizeof(IoctlSubmitGpfifo) == 16 + sizeof(Fence),
+    static_assert(sizeof(IoctlSubmitGpfifo) == 16 + sizeof(IoctlFence),
                   "IoctlSubmitGpfifo is incorrect size");
 
     struct IoctlGetWaitbase {
@@ -188,7 +184,6 @@ private:
     u32 ChannelSetTimeout(const std::vector<u8>& input, std::vector<u8>& output);
 
     std::shared_ptr<nvmap> nvmap_dev;
-    u32 assigned_syncpoints{};
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -10,11 +10,10 @@
 
 namespace Service::Nvidia::Devices {
 
-nvhost_nvdec::nvhost_nvdec(Core::System& system) : nvdevice(system) {}
+nvhost_nvdec::nvhost_nvdec() = default;
 nvhost_nvdec::~nvhost_nvdec() = default;
 
-u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                        IoctlCtrl& ctrl) {
+u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
               command.raw, input.size(), output.size());
 

src/core/hle/service/nvdrv/devices/nvhost_nvdec.h

@@ -13,11 +13,10 @@ namespace Service::Nvidia::Devices {
 
 class nvhost_nvdec final : public nvdevice {
 public:
-    explicit nvhost_nvdec(Core::System& system);
+    nvhost_nvdec();
     ~nvhost_nvdec() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
     enum class IoctlCommand : u32_le {

src/core/hle/service/nvdrv/devices/nvhost_nvjpg.cpp

@@ -10,11 +10,10 @@
 
 namespace Service::Nvidia::Devices {
 
-nvhost_nvjpg::nvhost_nvjpg(Core::System& system) : nvdevice(system) {}
+nvhost_nvjpg::nvhost_nvjpg() = default;
 nvhost_nvjpg::~nvhost_nvjpg() = default;
 
-u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                        IoctlCtrl& ctrl) {
+u32 nvhost_nvjpg::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
               command.raw, input.size(), output.size());
 

src/core/hle/service/nvdrv/devices/nvhost_nvjpg.h

@@ -13,11 +13,10 @@ namespace Service::Nvidia::Devices {
 
 class nvhost_nvjpg final : public nvdevice {
 public:
-    explicit nvhost_nvjpg(Core::System& system);
+    nvhost_nvjpg();
     ~nvhost_nvjpg() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
     enum class IoctlCommand : u32_le {

src/core/hle/service/nvdrv/devices/nvhost_vic.cpp

@@ -10,11 +10,10 @@
 
 namespace Service::Nvidia::Devices {
 
-nvhost_vic::nvhost_vic(Core::System& system) : nvdevice(system) {}
+nvhost_vic::nvhost_vic() = default;
 nvhost_vic::~nvhost_vic() = default;
 
-u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                      IoctlCtrl& ctrl) {
+u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     LOG_DEBUG(Service_NVDRV, "called, command=0x{:08X}, input_size=0x{:X}, output_size=0x{:X}",
               command.raw, input.size(), output.size());
 

src/core/hle/service/nvdrv/devices/nvhost_vic.h

@@ -13,11 +13,10 @@ namespace Service::Nvidia::Devices {
 
 class nvhost_vic final : public nvdevice {
 public:
-    explicit nvhost_vic(Core::System& system);
+    nvhost_vic();
     ~nvhost_vic() override;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
 private:
     enum class IoctlCommand : u32_le {

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -18,7 +18,7 @@ enum {
 };
 }
 
-nvmap::nvmap(Core::System& system) : nvdevice(system) {}
+nvmap::nvmap() = default;
 nvmap::~nvmap() = default;
 
 VAddr nvmap::GetObjectAddress(u32 handle) const {
@@ -28,8 +28,7 @@ VAddr nvmap::GetObjectAddress(u32 handle) const {
     return object->addr;
 }
 
-u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                 IoctlCtrl& ctrl) {
+u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
     switch (static_cast<IoctlCommand>(command.raw)) {
     case IoctlCommand::Create:
         return IocCreate(input, output);

src/core/hle/service/nvdrv/devices/nvmap.h

@@ -16,14 +16,13 @@ namespace Service::Nvidia::Devices {
 
 class nvmap final : public nvdevice {
 public:
-    explicit nvmap(Core::System& system);
+    nvmap();
     ~nvmap() override;
 
     /// Returns the allocated address of an nvmap object given its handle.
     VAddr GetObjectAddress(u32 handle) const;
 
-    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl) override;
+    u32 ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
 
     /// Represents an nvmap object.
     struct Object {

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

@@ -8,18 +8,12 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/nvdrv/interface.h"
-#include "core/hle/service/nvdrv/nvdata.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 
 namespace Service::Nvidia {
 
-void NVDRV::SignalGPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
-    nvdrv->SignalSyncpt(syncpoint_id, value);
-}
-
 void NVDRV::Open(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NVDRV, "called");
 
@@ -42,31 +36,11 @@ void NVDRV::Ioctl(Kernel::HLERequestContext& ctx) {
 
     std::vector<u8> output(ctx.GetWriteBufferSize());
 
-    IoctlCtrl ctrl{};
-
-    u32 result = nvdrv->Ioctl(fd, command, ctx.ReadBuffer(), output, ctrl);
-
-    if (ctrl.must_delay) {
-        ctrl.fresh_call = false;
-        ctx.SleepClientThread(
-            "NVServices::DelayedResponse", ctrl.timeout,
-            [=](Kernel::SharedPtr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
-                Kernel::ThreadWakeupReason reason) {
-                IoctlCtrl ctrl2{ctrl};
-                std::vector<u8> output2 = output;
-                u32 result = nvdrv->Ioctl(fd, command, ctx.ReadBuffer(), output2, ctrl2);
-                ctx.WriteBuffer(output2);
-                IPC::ResponseBuilder rb{ctx, 3};
-                rb.Push(RESULT_SUCCESS);
-                rb.Push(result);
-            },
-            nvdrv->GetEventWriteable(ctrl.event_id));
-    } else {
-        ctx.WriteBuffer(output);
-    }
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(result);
+    rb.Push(nvdrv->Ioctl(fd, command, ctx.ReadBuffer(), output));
+
+    ctx.WriteBuffer(output);
 }
 
 void NVDRV::Close(Kernel::HLERequestContext& ctx) {
@@ -92,19 +66,13 @@ void NVDRV::Initialize(Kernel::HLERequestContext& ctx) {
 void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     u32 fd = rp.Pop<u32>();
-    // TODO(Blinkhawk): Figure the meaning of the flag at bit 16
-    u32 event_id = rp.Pop<u32>() & 0x000000FF;
+    u32 event_id = rp.Pop<u32>();
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, fd={:X}, event_id={:X}", fd, event_id);
 
     IPC::ResponseBuilder rb{ctx, 3, 1};
     rb.Push(RESULT_SUCCESS);
-    if (event_id < MaxNvEvents) {
-        rb.PushCopyObjects(nvdrv->GetEvent(event_id));
-        rb.Push<u32>(NvResult::Success);
-    } else {
-        rb.Push<u32>(0);
-        rb.Push<u32>(NvResult::BadParameter);
-    }
+    rb.PushCopyObjects(query_event.readable);
+    rb.Push<u32>(0);
 }
 
 void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
@@ -159,6 +127,10 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
         {13, &NVDRV::FinishInitialize, "FinishInitialize"},
     };
     RegisterHandlers(functions);
+
+    auto& kernel = Core::System::GetInstance().Kernel();
+    query_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
+                                                         "NVDRV::query_event");
 }
 
 NVDRV::~NVDRV() = default;

src/core/hle/service/nvdrv/interface.h

@@ -19,8 +19,6 @@ public:
     NVDRV(std::shared_ptr<Module> nvdrv, const char* name);
     ~NVDRV() override;
 
-    void SignalGPUInterruptSyncpt(const u32 syncpoint_id, const u32 value);
-
 private:
     void Open(Kernel::HLERequestContext& ctx);
     void Ioctl(Kernel::HLERequestContext& ctx);
@@ -35,6 +33,8 @@ private:
     std::shared_ptr<Module> nvdrv;
 
     u64 pid{};
+
+    Kernel::EventPair query_event;
 };
 
 } // namespace Service::Nvidia

src/core/hle/service/nvdrv/nvdata.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <array>
-#include "common/common_types.h"
-
-namespace Service::Nvidia {
-
-constexpr u32 MaxSyncPoints = 192;
-constexpr u32 MaxNvEvents = 64;
-
-struct Fence {
-    s32 id;
-    u32 value;
-};
-
-static_assert(sizeof(Fence) == 8, "Fence has wrong size");
-
-struct MultiFence {
-    u32 num_fences;
-    std::array<Fence, 4> fences;
-};
-
-enum NvResult : u32 {
-    Success = 0,
-    BadParameter = 4,
-    Timeout = 5,
-    ResourceError = 15,
-};
-
-enum class EventState {
-    Free = 0,
-    Registered = 1,
-    Waiting = 2,
-    Busy = 3,
-};
-
-struct IoctlCtrl {
-    // First call done to the servioce for services that call itself again after a call.
-    bool fresh_call{true};
-    // Tells the Ioctl Wrapper that it must delay the IPC response and send the thread to sleep
-    bool must_delay{};
-    // Timeout for the delay
-    s64 timeout{};
-    // NV Event Id
-    s32 event_id{-1};
-};
-
-} // namespace Service::Nvidia

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -4,10 +4,7 @@
 
 #include <utility>
 
-#include <fmt/format.h>
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/devices/nvhost_as_gpu.h"
@@ -25,9 +22,8 @@
 
 namespace Service::Nvidia {
 
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
-                       Core::System& system) {
-    auto module_ = std::make_shared<Module>(system);
+void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger) {
+    auto module_ = std::make_shared<Module>();
     std::make_shared<NVDRV>(module_, "nvdrv")->InstallAsService(service_manager);
     std::make_shared<NVDRV>(module_, "nvdrv:a")->InstallAsService(service_manager);
     std::make_shared<NVDRV>(module_, "nvdrv:s")->InstallAsService(service_manager);
@@ -36,25 +32,17 @@ void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger
     nvflinger.SetNVDrvInstance(module_);
 }
 
-Module::Module(Core::System& system) {
-    auto& kernel = system.Kernel();
-    for (u32 i = 0; i < MaxNvEvents; i++) {
-        std::string event_label = fmt::format("NVDRV::NvEvent_{}", i);
-        events_interface.events[i] = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::Automatic, event_label);
-        events_interface.status[i] = EventState::Free;
-        events_interface.registered[i] = false;
-    }
-    auto nvmap_dev = std::make_shared<Devices::nvmap>(system);
-    devices["/dev/nvhost-as-gpu"] = std::make_shared<Devices::nvhost_as_gpu>(system, nvmap_dev);
-    devices["/dev/nvhost-gpu"] = std::make_shared<Devices::nvhost_gpu>(system, nvmap_dev);
-    devices["/dev/nvhost-ctrl-gpu"] = std::make_shared<Devices::nvhost_ctrl_gpu>(system);
+Module::Module() {
+    auto nvmap_dev = std::make_shared<Devices::nvmap>();
+    devices["/dev/nvhost-as-gpu"] = std::make_shared<Devices::nvhost_as_gpu>(nvmap_dev);
+    devices["/dev/nvhost-gpu"] = std::make_shared<Devices::nvhost_gpu>(nvmap_dev);
+    devices["/dev/nvhost-ctrl-gpu"] = std::make_shared<Devices::nvhost_ctrl_gpu>();
     devices["/dev/nvmap"] = nvmap_dev;
-    devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(system, nvmap_dev);
-    devices["/dev/nvhost-ctrl"] = std::make_shared<Devices::nvhost_ctrl>(system, events_interface);
-    devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>(system);
-    devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>(system);
-    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>(system);
+    devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(nvmap_dev);
+    devices["/dev/nvhost-ctrl"] = std::make_shared<Devices::nvhost_ctrl>();
+    devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>();
+    devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>();
+    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>();
 }
 
 Module::~Module() = default;
@@ -71,13 +59,12 @@ u32 Module::Open(const std::string& device_name) {
     return fd;
 }
 
-u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output,
-                  IoctlCtrl& ctrl) {
+u32 Module::Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output) {
     auto itr = open_files.find(fd);
     ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
 
     auto& device = itr->second;
-    return device->ioctl({command}, input, output, ctrl);
+    return device->ioctl({command}, input, output);
 }
 
 ResultCode Module::Close(u32 fd) {
@@ -90,22 +77,4 @@ ResultCode Module::Close(u32 fd) {
     return RESULT_SUCCESS;
 }
 
-void Module::SignalSyncpt(const u32 syncpoint_id, const u32 value) {
-    for (u32 i = 0; i < MaxNvEvents; i++) {
-        if (events_interface.assigned_syncpt[i] == syncpoint_id &&
-            events_interface.assigned_value[i] == value) {
-            events_interface.LiberateEvent(i);
-            events_interface.events[i].writable->Signal();
-        }
-    }
-}
-
-Kernel::SharedPtr<Kernel::ReadableEvent> Module::GetEvent(const u32 event_id) const {
-    return events_interface.events[event_id].readable;
-}
-
-Kernel::SharedPtr<Kernel::WritableEvent> Module::GetEventWriteable(const u32 event_id) const {
-    return events_interface.events[event_id].writable;
-}
-
 } // namespace Service::Nvidia

src/core/hle/service/nvdrv/nvdrv.h

@@ -8,14 +8,8 @@
 #include <unordered_map>
 #include <vector>
 #include "common/common_types.h"
-#include "core/hle/kernel/writable_event.h"
-#include "core/hle/service/nvdrv/nvdata.h"
 #include "core/hle/service/service.h"
 
-namespace Core {
-class System;
-}
-
 namespace Service::NVFlinger {
 class NVFlinger;
 }
@@ -26,72 +20,16 @@ namespace Devices {
 class nvdevice;
 }
 
-struct EventInterface {
-    // Mask representing currently busy events
-    u64 events_mask{};
-    // Each kernel event associated to an NV event
-    std::array<Kernel::EventPair, MaxNvEvents> events;
-    // The status of the current NVEvent
-    std::array<EventState, MaxNvEvents> status{};
-    // Tells if an NVEvent is registered or not
-    std::array<bool, MaxNvEvents> registered{};
-    // When an NVEvent is waiting on GPU interrupt, this is the sync_point
-    // associated with it.
-    std::array<u32, MaxNvEvents> assigned_syncpt{};
-    // This is the value of the GPU interrupt for which the NVEvent is waiting
-    // for.
-    std::array<u32, MaxNvEvents> assigned_value{};
-    // Constant to denote an unasigned syncpoint.
-    static constexpr u32 unassigned_syncpt = 0xFFFFFFFF;
-    std::optional<u32> GetFreeEvent() const {
-        u64 mask = events_mask;
-        for (u32 i = 0; i < MaxNvEvents; i++) {
-            const bool is_free = (mask & 0x1) == 0;
-            if (is_free) {
-                if (status[i] == EventState::Registered || status[i] == EventState::Free) {
-                    return {i};
-                }
-            }
-            mask = mask >> 1;
-        }
-        return {};
-    }
-    void SetEventStatus(const u32 event_id, EventState new_status) {
-        EventState old_status = status[event_id];
-        if (old_status == new_status) {
-            return;
-        }
-        status[event_id] = new_status;
-        if (new_status == EventState::Registered) {
-            registered[event_id] = true;
-        }
-        if (new_status == EventState::Waiting || new_status == EventState::Busy) {
-            events_mask |= (1ULL << event_id);
-        }
-    }
-    void RegisterEvent(const u32 event_id) {
-        registered[event_id] = true;
-        if (status[event_id] == EventState::Free) {
-            status[event_id] = EventState::Registered;
-        }
-    }
-    void UnregisterEvent(const u32 event_id) {
-        registered[event_id] = false;
-        if (status[event_id] == EventState::Registered) {
-            status[event_id] = EventState::Free;
-        }
-    }
-    void LiberateEvent(const u32 event_id) {
-        status[event_id] = registered[event_id] ? EventState::Registered : EventState::Free;
-        events_mask &= ~(1ULL << event_id);
-        assigned_syncpt[event_id] = unassigned_syncpt;
-        assigned_value[event_id] = 0;
-    }
+struct IoctlFence {
+    u32 id;
+    u32 value;
 };
 
+static_assert(sizeof(IoctlFence) == 8, "IoctlFence has wrong size");
+
 class Module final {
 public:
-    Module(Core::System& system);
+    Module();
     ~Module();
 
     /// Returns a pointer to one of the available devices, identified by its name.
@@ -106,17 +44,10 @@ public:
     /// Opens a device node and returns a file descriptor to it.
     u32 Open(const std::string& device_name);
     /// Sends an ioctl command to the specified file descriptor.
-    u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output,
-              IoctlCtrl& ctrl);
+    u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output);
     /// Closes a device file descriptor and returns operation success.
     ResultCode Close(u32 fd);
 
-    void SignalSyncpt(const u32 syncpoint_id, const u32 value);
-
-    Kernel::SharedPtr<Kernel::ReadableEvent> GetEvent(u32 event_id) const;
-
-    Kernel::SharedPtr<Kernel::WritableEvent> GetEventWriteable(u32 event_id) const;
-
 private:
     /// Id to use for the next open file descriptor.
     u32 next_fd = 1;
@@ -126,12 +57,9 @@ private:
 
     /// Mapping of device node names to their implementation.
     std::unordered_map<std::string, std::shared_ptr<Devices::nvdevice>> devices;
-
-    EventInterface events_interface;
 };
 
 /// Registers all NVDRV services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
-                       Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger);
 
 } // namespace Service::Nvidia

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -34,8 +34,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
     buffer_wait_event.writable->Signal();
 }
 
-std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::DequeueBuffer(u32 width,
-                                                                                       u32 height) {
+std::optional<u32> BufferQueue::DequeueBuffer(u32 width, u32 height) {
     auto itr = std::find_if(queue.begin(), queue.end(), [&](const Buffer& buffer) {
         // Only consider free buffers. Buffers become free once again after they've been Acquired
         // and Released by the compositor, see the NVFlinger::Compose method.
@@ -52,7 +51,7 @@ std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::Dequeue
     }
 
     itr->status = Buffer::Status::Dequeued;
-    return {{itr->slot, &itr->multi_fence}};
+    return itr->slot;
 }
 
 const IGBPBuffer& BufferQueue::RequestBuffer(u32 slot) const {
@@ -64,8 +63,7 @@ const IGBPBuffer& BufferQueue::RequestBuffer(u32 slot) const {
 }
 
 void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
-                              const Common::Rectangle<int>& crop_rect, u32 swap_interval,
-                              Service::Nvidia::MultiFence& multi_fence) {
+                              const Common::Rectangle<int>& crop_rect) {
     auto itr = std::find_if(queue.begin(), queue.end(),
                             [&](const Buffer& buffer) { return buffer.slot == slot; });
     ASSERT(itr != queue.end());
@@ -73,21 +71,12 @@ void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
     itr->status = Buffer::Status::Queued;
     itr->transform = transform;
     itr->crop_rect = crop_rect;
-    itr->swap_interval = swap_interval;
-    itr->multi_fence = multi_fence;
-    queue_sequence.push_back(slot);
 }
 
 std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::AcquireBuffer() {
-    auto itr = queue.end();
-    // Iterate to find a queued buffer matching the requested slot.
-    while (itr == queue.end() && !queue_sequence.empty()) {
-        u32 slot = queue_sequence.front();
-        itr = std::find_if(queue.begin(), queue.end(), [&slot](const Buffer& buffer) {
-            return buffer.status == Buffer::Status::Queued && buffer.slot == slot;
-        });
-        queue_sequence.pop_front();
-    }
+    auto itr = std::find_if(queue.begin(), queue.end(), [](const Buffer& buffer) {
+        return buffer.status == Buffer::Status::Queued;
+    });
     if (itr == queue.end())
         return {};
     itr->status = Buffer::Status::Acquired;

src/core/hle/service/nvflinger/buffer_queue.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <list>
 #include <optional>
 #include <vector>
 
@@ -13,7 +12,6 @@
 #include "common/swap.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/writable_event.h"
-#include "core/hle/service/nvdrv/nvdata.h"
 
 namespace Service::NVFlinger {
 
@@ -70,17 +68,13 @@ public:
         IGBPBuffer igbp_buffer;
         BufferTransformFlags transform;
         Common::Rectangle<int> crop_rect;
-        u32 swap_interval;
-        Service::Nvidia::MultiFence multi_fence;
     };
 
     void SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer);
-    std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> DequeueBuffer(u32 width,
-                                                                              u32 height);
+    std::optional<u32> DequeueBuffer(u32 width, u32 height);
     const IGBPBuffer& RequestBuffer(u32 slot) const;
     void QueueBuffer(u32 slot, BufferTransformFlags transform,
-                     const Common::Rectangle<int>& crop_rect, u32 swap_interval,
-                     Service::Nvidia::MultiFence& multi_fence);
+                     const Common::Rectangle<int>& crop_rect);
     std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
     void ReleaseBuffer(u32 slot);
     u32 Query(QueryType type);
@@ -98,7 +92,6 @@ private:
     u64 layer_id;
 
     std::vector<Buffer> queue;
-    std::list<u32> queue_sequence;
     Kernel::EventPair buffer_wait_event;
 };
 

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -37,14 +37,15 @@ NVFlinger::NVFlinger(Core::Timing::CoreTiming& core_timing) : core_timing{core_t
     displays.emplace_back(4, "Null");
 
     // Schedule the screen composition events
-    composition_event = core_timing.RegisterEvent("ScreenComposition", [this](u64 userdata,
-                                                                              s64 cycles_late) {
-        Compose();
-        const auto ticks = Settings::values.force_30fps_mode ? frame_ticks_30fps : GetNextTicks();
-        this->core_timing.ScheduleEvent(std::max<s64>(0LL, ticks - cycles_late), composition_event);
-    });
+    const auto ticks = Settings::values.force_30fps_mode ? frame_ticks_30fps : frame_ticks;
 
-    core_timing.ScheduleEvent(frame_ticks, composition_event);
+    composition_event = core_timing.RegisterEvent(
+        "ScreenComposition", [this, ticks](u64 userdata, s64 cycles_late) {
+            Compose();
+            this->core_timing.ScheduleEvent(ticks - cycles_late, composition_event);
+        });
+
+    core_timing.ScheduleEvent(ticks, composition_event);
 }
 
 NVFlinger::~NVFlinger() {
@@ -205,14 +206,8 @@ void NVFlinger::Compose() {
                      igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride,
                      buffer->get().transform, buffer->get().crop_rect);
 
-        swap_interval = buffer->get().swap_interval;
         buffer_queue.ReleaseBuffer(buffer->get().slot);
     }
 }
 
-s64 NVFlinger::GetNextTicks() const {
-    constexpr s64 max_hertz = 120LL;
-    return (Core::Timing::BASE_CLOCK_RATE * (1LL << swap_interval)) / max_hertz;
-}
-
 } // namespace Service::NVFlinger

src/core/hle/service/nvflinger/nvflinger.h

@@ -74,8 +74,6 @@ public:
     /// finished.
     void Compose();
 
-    s64 GetNextTicks() const;
-
 private:
     /// Finds the display identified by the specified ID.
     VI::Display* FindDisplay(u64 display_id);
@@ -100,8 +98,6 @@ private:
     /// layers.
     u32 next_buffer_queue_id = 1;
 
-    u32 swap_interval = 1;
-
     /// Event that handles screen composition.
     Core::Timing::EventType* composition_event;