Update translations (2022-12-01)

Merge pull request #9320 from yuzu-emu/fix-audio-suspend
AudioCore: Take suspend lock when stalling the running process.
2022-12-01 03:00:13 +00:00 · 2022-11-30 16:41:32 +01:00 · 2022-11-29 20:32:06 -08:00 · 2022-11-29 19:41:47 -05:00 · 2022-11-29 18:45:39 -05:00 · 2022-11-29 18:45:25 -05:00
268 changed files with 26849 additions and 16081 deletions
@@ -0,0 +1,10 @@
+name: New Issue (Developers Only)
+description: A blank issue template for developers only. If you are not a developer, do not use this issue template. Your issue WILL BE CLOSED if you do not use the appropriate issue template.
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **If you are not a developer, do not use this issue template. Your issue WILL BE CLOSED if you do not use the appropriate issue template.**
+  - type: textarea
+    attributes:
+      label: "Issue"
@@ -1,39 +0,0 @@
---
-name: Bug Report / Feature Request
-about: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with yuzu or you are requesting a feature you believe would make yuzu better.
-title: ''
-labels: ''
-assignees: ''
-
---
-
-<!---
-Please keep in mind yuzu is EXPERIMENTAL SOFTWARE.
-
-Please read the FAQ:
-https://yuzu-emu.org/wiki/faq/
-
-THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
-https://community.citra-emu.org/
-
-If the FAQ does not answer your question, please go to:
-https://community.citra-emu.org/
-
-When submitting an issue, please check the following:
-
- You have read the above.
- You have provided the version (commit hash) of yuzu you are using.
- You have provided sufficient detail for the issue to be reproduced.
- You have provided system specs (if relevant).
- Please also provide:
-  - For any issues, a log file
-  - For crashes, a backtrace.
-  - For graphical issues, comparison screenshots with real hardware.
-  - For emulation inaccuracies, a test-case (if able).
-
-->
-
-
-
-
-
@@ -0,0 +1,64 @@
+name: Bug Report
+description: File a bug report
+body:
+  - type: markdown
+    attributes:
+      value: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with yuzu.
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search to see if an issue already exists for the bug you encountered.
+      options:
+      - label: I have searched the existing issues
+        required: true
+  - type: input
+    attributes:
+      label: Affected Build(s)
+      description: List the affected build(s) that this issue applies to.
+      placeholder: Mainline 1234 / Early Access 1234
+    validations:
+      required: true
+  - type: textarea
+    id: issue-desc
+    attributes:
+      label: Description of Issue
+      description: A brief description of the issue encountered along with any images and/or videos.
+    validations:
+      required: true
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected Behavior
+      description: A brief description of how it is expected to work along with any images and/or videos.
+    validations:
+      required: true
+  - type: textarea
+    id: reproduction-steps
+    attributes:
+      label: Reproduction Steps
+      description: A brief explanation of how to reproduce this issue. If possible, provide a save file to aid in reproducing the issue.
+    validations:
+      required: true
+  - type: textarea
+    id: log
+    attributes:
+      label: Log File
+      description: A log file will help our developers to better diagnose and fix the issue.
+    validations:
+      required: true
+  - type: textarea
+    id: system-config
+    attributes:
+      label: System Configuration
+      placeholder: |
+        CPU: Intel i5-10400 / AMD Ryzen 5 3600
+        GPU/Driver: NVIDIA GeForce GTX 1060 (Driver 512.95)
+        RAM: 16GB DDR4-3200
+        OS: Windows 11 22H2 (Build 22621.819)
+      value: |
+        CPU:
+        GPU/Driver:
+        RAM:
+        OS:
+    validations:
+      required: true
@@ -0,0 +1,28 @@
+name: Feature Request
+description: File a feature request
+labels: "request"
+body:
+  - type: markdown
+    attributes:
+      value: Tech support does not belong here. You should only file an issue here if you are requesting a feature you believe would make yuzu better.
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search to see if an issue already exists for the feature you are requesting.
+      options:
+      - label: I have searched the existing issues
+        required: true
+  - type: textarea
+    id: what-feature
+    attributes:
+      label: What feature are you suggesting?
+      description: A brief description of the requested feature.
+    validations:
+      required: true
+  - type: textarea
+    id: why-feature
+    attributes:
+      label: Why would this feature be useful?
+      description: A brief description of why this feature would make yuzu better.
+    validations:
+      required: true
@@ -132,10 +132,6 @@ Files: vcpkg.json
 Copyright: 2022 yuzu Emulator Project
 License: GPL-3.0-or-later

-Files: .github/ISSUE_TEMPLATE/config.yml
-Copyright: 2020 tgsm <doodrabbit@hotmail.com>
-License: GPL-2.0-or-later
-
-Files: .github/ISSUE_TEMPLATE/bug-report-feature-request.md
-Copyright: 2016 MerryMage
+Files: .github/ISSUE_TEMPLATE/*
+Copyright: 2022 yuzu Emulator Project
 License: GPL-2.0-or-later
@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later

-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.22)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
@@ -19,6 +19,9 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)

 option(ENABLE_QT "Enable the Qt frontend" ON)
+option(ENABLE_QT6 "Allow usage of Qt6 to be attempted" OFF)
+set(QT6_LOCATION "" CACHE PATH "Additional Location to search for Qt6 libraries like C:/Qt/6.3.1/msvc2019_64/")
+
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)

@@ -28,6 +31,8 @@ option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)

 option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")

+option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
+
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)

 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
@@ -133,13 +138,13 @@ if (NOT ENABLE_GENERIC)
    if (MSVC)
        detect_architecture("_M_AMD64" x86_64)
        detect_architecture("_M_IX86" x86)
-        detect_architecture("_M_ARM" ARM)
-        detect_architecture("_M_ARM64" ARM64)
+        detect_architecture("_M_ARM" arm)
+        detect_architecture("_M_ARM64" arm64)
    else()
        detect_architecture("__x86_64__" x86_64)
        detect_architecture("__i386__" x86)
-        detect_architecture("__arm__" ARM)
-        detect_architecture("__aarch64__" ARM64)
+        detect_architecture("__arm__" arm)
+        detect_architecture("__aarch64__" arm64)
    endif()
 endif()

@@ -213,128 +218,166 @@ if (MINGW)
    find_library(MSWSOCK_LIBRARY mswsock REQUIRED)
 endif()

+# Please consider this as a stub
+if(ENABLE_QT6 AND Qt6_LOCATION)
+    list(APPEND CMAKE_PREFIX_PATH "${Qt6_LOCATION}")
+endif()
+
+function(set_yuzu_qt_components)
+    # Best practice is to ask for all components at once, so they are from the same version
+    set(YUZU_QT_COMPONENTS2 Core Widgets Concurrent)
+    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+        list(APPEND YUZU_QT_COMPONENTS2 DBus)
+    endif()
+    if (YUZU_USE_QT_MULTIMEDIA)
+        list(APPEND YUZU_QT_COMPONENTS2 Multimedia)
+    endif()
+    if (YUZU_USE_QT_WEB_ENGINE)
+        list(APPEND YUZU_QT_COMPONENTS2 WebEngineCore WebEngineWidgets)
+    endif()
+    if (ENABLE_QT_TRANSLATION)
+        list(APPEND YUZU_QT_COMPONENTS2 LinguistTools)
+    endif()
+    set(YUZU_QT_COMPONENTS ${YUZU_QT_COMPONENTS2} PARENT_SCOPE)
+endfunction(set_yuzu_qt_components)
+
 # Qt5 requires that we find components, so it doesn't fit our pretty little find package function
 if(ENABLE_QT)
    set(QT_VERSION 5.15)
+    # These are used to specify minimum versions
+    set(QT5_VERSION 5.15)
+    set(QT6_VERSION 6.3.1)

-    # Check for system Qt on Linux, fallback to bundled Qt
-    if (UNIX AND NOT APPLE)
-        if (NOT YUZU_USE_BUNDLED_QT)
-            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets DBus Multimedia)
-        endif()
-        if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT))
-            # Check for dependencies, then enable bundled Qt download
-
-            # Check that the system GLIBCXX version is compatible
-            find_program(OBJDUMP objdump)
-            if ("${OBJDUMP}" STREQUAL "OBJDUMP-NOTFOUND")
-                message(FATAL_ERROR "Required program `objdump` not found.")
-            endif()
-            find_library(LIBSTDCXX libstdc++.so.6)
-            execute_process(
-                COMMAND
-                    ${OBJDUMP} -T ${LIBSTDCXX}
-                COMMAND
-                    grep GLIBCXX_3.4.28
-                COMMAND
-                    sed "s/[0-9a-f]*.*  //"
-                COMMAND
-                    sed "s/ .*//"
-                COMMAND
-                    sort -u
-                OUTPUT_VARIABLE
-                    GLIBCXX_MET
-            )
-            if (NOT GLIBCXX_MET)
-                message(FATAL_ERROR "Qt too old or not found, and bundled Qt package is not \
-                    compatible with this system. Either install Qt ${QT_VERSION}, or provide the path \
-                    to Qt by setting the variable Qt5_ROOT.")
-            endif()
-
-            # Check for headers
-            find_package(PkgConfig REQUIRED)
-            pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
-            if (NOT QT_DEP_GLU_FOUND)
-                message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
-                    Perhaps `libglu1-mesa-dev` needs to be installed?")
-            endif()
-            pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
-            if (NOT QT_DEP_MESA_FOUND)
-                message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
-                    Perhaps `mesa-common-dev` needs to be installed?")
-            endif()
-
-            # Check for X libraries
-            set(BUNDLED_QT_REQUIREMENTS
-                libxcb-icccm.so.4
-                libxcb-image.so.0
-                libxcb-keysyms.so.1
-                libxcb-randr.so.0
-                libxcb-render-util.so.0
-                libxcb-render.so.0
-                libxcb-shape.so.0
-                libxcb-shm.so.0
-                libxcb-sync.so.1
-                libxcb-xfixes.so.0
-                libxcb-xinerama.so.0
-                libxcb-xkb.so.1
-                libxcb.so.1
-                libxkbcommon-x11.so.0
-                libxkbcommon.so.0
-            )
-            set(UNRESOLVED_QT_DEPS "")
-            foreach (REQUIREMENT ${BUNDLED_QT_REQUIREMENTS})
-                find_library(BUNDLED_QT_${REQUIREMENT} ${REQUIREMENT})
-                if ("${BUNDLED_QT_${REQUIREMENT}}" STREQUAL "BUNDLED_QT_${REQUIREMENT}-NOTFOUND")
-                    set(UNRESOLVED_QT_DEPS ${UNRESOLVED_QT_DEPS} ${REQUIREMENT})
-                endif()
-                unset(BUNDLED_QT_${REQUIREMENT})
-            endforeach()
-            unset(BUNDLED_QT_REQUIREMENTS)
-
-            if (NOT "${UNRESOLVED_QT_DEPS}" STREQUAL "")
-                message(FATAL_ERROR "Bundled Qt package missing required dependencies: ${UNRESOLVED_QT_DEPS}")
-            endif()
-
-            set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
-        endif()
-        if (YUZU_USE_BUNDLED_QT)
-            # Binary package currently does not support Qt webengine, so make sure it's disabled
-            set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
-        endif()
+    set_yuzu_qt_components()
+    if (ENABLE_QT6)
+        find_package(Qt6 ${QT6_VERSION} COMPONENTS ${YUZU_QT_COMPONENTS})
    endif()
-
-    set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
-
-    if(YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
-            set(QT_BUILD qt-5.15.2-msvc2019_64)
-        elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
-            set(QT_BUILD qt5_5_15_2)
-        else()
-            message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
-        endif()
-
-        if (DEFINED QT_BUILD)
-            download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
-        endif()
-
-        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
-
-        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
-    endif()
-    if (UNIX AND NOT APPLE AND YUZU_USE_BUNDLED_QT)
-        find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia DBus ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
+    if (Qt6_FOUND)
+        message(STATUS "yuzu/CMakeLists.txt: Qt6Widgets_VERSION ${Qt6Widgets_VERSION}, setting QT_VERSION")
+        set(QT_VERSION ${Qt6Widgets_VERSION})
+        set(QT_MAJOR_VERSION 6)
+        # Qt6 sets cxx_std_17 and we need to undo that
+        set_target_properties(Qt6::Platform PROPERTIES INTERFACE_COMPILE_FEATURES "")
    else()
-        find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
-    endif()
-    if (YUZU_USE_QT_WEB_ENGINE)
-        find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
+        message(STATUS "yuzu/CMakeLists.txt: Qt6 not found/not selected, trying for Qt5")
+        # When Qt6 partially found, need this set to use Qt5 when not specifying version
+        set(QT_DEFAULT_MAJOR_VERSION 5)
+        set(QT_MAJOR_VERSION 5)
+
+        set(YUZU_USE_QT_MULTIMEDIA ON)
+        # Check for system Qt on Linux, fallback to bundled Qt
+        if (UNIX AND NOT APPLE)
+            if (NOT YUZU_USE_BUNDLED_QT)
+                find_package(Qt5 ${QT5_VERSION} COMPONENTS Widgets DBus Multimedia)
+            endif()
+            if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT))
+                # Check for dependencies, then enable bundled Qt download
+
+                # Check that the system GLIBCXX version is compatible
+                find_program(OBJDUMP objdump)
+                if (NOT OBJDUMP)
+                    message(FATAL_ERROR "Required program `objdump` not found.")
+                endif()
+                find_library(LIBSTDCXX libstdc++.so.6)
+                execute_process(
+                    COMMAND
+                        ${OBJDUMP} -T ${LIBSTDCXX}
+                    COMMAND
+                        grep GLIBCXX_3.4.28
+                    COMMAND
+                        sed "s/[0-9a-f]*.*  //"
+                    COMMAND
+                        sed "s/ .*//"
+                    COMMAND
+                        sort -u
+                    OUTPUT_VARIABLE
+                        GLIBCXX_MET
+                )
+                if (NOT GLIBCXX_MET)
+                    message(FATAL_ERROR "Qt too old or not found, and bundled Qt package is not \
+                        compatible with this system. Either install Qt ${QT_VERSION}, or provide the path \
+                        to Qt by setting the variable Qt5_ROOT.")
+                endif()
+
+                # Check for headers
+                find_package(PkgConfig REQUIRED)
+                pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
+                if (NOT QT_DEP_GLU_FOUND)
+                    message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
+                        Perhaps `libglu1-mesa-dev` needs to be installed?")
+                endif()
+                pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
+                if (NOT QT_DEP_MESA_FOUND)
+                    message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
+                        Perhaps `mesa-common-dev` needs to be installed?")
+                endif()
+
+                # Check for X libraries
+                set(BUNDLED_QT_REQUIREMENTS
+                    libxcb-icccm.so.4
+                    libxcb-image.so.0
+                    libxcb-keysyms.so.1
+                    libxcb-randr.so.0
+                    libxcb-render-util.so.0
+                    libxcb-render.so.0
+                    libxcb-shape.so.0
+                    libxcb-shm.so.0
+                    libxcb-sync.so.1
+                    libxcb-xfixes.so.0
+                    libxcb-xinerama.so.0
+                    libxcb-xkb.so.1
+                    libxcb.so.1
+                    libxkbcommon-x11.so.0
+                    libxkbcommon.so.0
+                )
+                set(UNRESOLVED_QT_DEPS "")
+                foreach (REQUIREMENT ${BUNDLED_QT_REQUIREMENTS})
+                    find_library(BUNDLED_QT_${REQUIREMENT} ${REQUIREMENT})
+                    if (NOT BUNDLED_QT_${REQUIREMENT})
+                        set(UNRESOLVED_QT_DEPS ${UNRESOLVED_QT_DEPS} ${REQUIREMENT})
+                    endif()
+                    unset(BUNDLED_QT_${REQUIREMENT})
+                endforeach()
+                unset(BUNDLED_QT_REQUIREMENTS)
+
+                if (NOT "${UNRESOLVED_QT_DEPS}" STREQUAL "")
+                    message(FATAL_ERROR "Bundled Qt package missing required dependencies: ${UNRESOLVED_QT_DEPS}")
+                endif()
+
+                set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
+            endif()
+            if (YUZU_USE_BUNDLED_QT)
+                # Binary package currently does not support Qt webengine, so make sure it's disabled
+                set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
+            endif()
+        endif()
+
+        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
+
+        if(YUZU_USE_BUNDLED_QT)
+            if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
+                set(QT_BUILD qt-5.15.2-msvc2019_64)
+            elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
+                set(QT_BUILD qt5_5_15_2)
+            else()
+                message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
+            endif()
+
+            if (DEFINED QT_BUILD)
+                download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
+            endif()
+
+            set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
+
+            set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
+            # Binary package for Qt5 has Qt Multimedia
+            set(YUZU_USE_QT_MULTIMEDIA ON CACHE BOOL "Use Qt Multimedia" FORCE)
+        endif()
+
+        set_yuzu_qt_components()
+        find_package(Qt5 ${QT5_VERSION} COMPONENTS ${YUZU_QT_COMPONENTS} ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
    endif()

-    if (ENABLE_QT_TRANSLATION)
-        find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
-    endif()
 endif()

 # find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the yuzu_find_package
@@ -27,10 +27,13 @@ function(copy_yuzu_Qt5_deps target_dir)
            Qt5Core$<$<CONFIG:Debug>:d>.*
            Qt5Gui$<$<CONFIG:Debug>:d>.*
            Qt5Widgets$<$<CONFIG:Debug>:d>.*
-            Qt5Multimedia$<$<CONFIG:Debug>:d>.*
            Qt5Network$<$<CONFIG:Debug>:d>.*
        )
-
+        if (YUZU_USE_QT_MULTIMEDIA)
+            windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
+                Qt5Multimedia$<$<CONFIG:Debug>:d>.*
+            )
+        endif()
        if (YUZU_USE_QT_WEB_ENGINE)
            windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
                Qt5Network$<$<CONFIG:Debug>:d>.*
@@ -7,15 +7,14 @@ include(DownloadExternals)

 # xbyak
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    add_library(xbyak INTERFACE)
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/xbyak/xbyak DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    target_include_directories(xbyak SYSTEM INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
+    add_subdirectory(xbyak)
 endif()

 # Dynarmic
-if (ARCHITECTURE_x86_64)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
+    if (ARCHITECTURE_arm64)
+       set(DYNARMIC_FRONTENDS "A32")
+    endif()
    set(DYNARMIC_NO_BUNDLED_FMT ON)
    set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
    add_subdirectory(dynarmic)
@@ -70,7 +69,6 @@ if (YUZU_USE_EXTERNAL_SDL2)
    set(SDL_SHARED OFF)

    add_subdirectory(SDL EXCLUDE_FROM_ALL)
-    add_library(SDL2 ALIAS SDL2-static)
 endif()

 # ENet
@@ -93,10 +91,14 @@ endif()
 add_subdirectory(sirit)

 if (ENABLE_WEB_SERVICE)
-    find_package(OpenSSL 1.1)
-    if (OPENSSL_FOUND)
-        set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
-    else()
+    if (NOT WIN32)
+        find_package(OpenSSL 1.1)
+        if (OPENSSL_FOUND)
+            set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
+        endif()
+    endif()
+
+    if (WIN32 OR NOT OPENSSL_FOUND)
        # LibreSSL
        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
        set(OPENSSLDIR "/etc/ssl/")
@@ -845,8 +845,6 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
    MicroProfile& S = *MicroProfileGet();
    MP_DEBUG_DUMP_RANGE();
    int nY = nBaseY - UI.nOffsetY;
-    int64_t nNumBoxes = 0;
-    int64_t nNumLines = 0;

    uint32_t nFrameNext = (S.nFrameCurrent+1) % MICROPROFILE_MAX_FRAME_HISTORY;
    MicroProfileFrameState* pFrameCurrent = &S.Frames[S.nFrameCurrent];
@@ -1149,7 +1147,6 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                                }
                            }
 #endif
-                            ++nNumBoxes;
                        }
                        else
                        {
@@ -1165,7 +1162,6 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                                }
                                nLinesDrawn[nStackPos] = nLineX;
                                MicroProfileDrawLineVertical(nLineX, fYStart + 0.5f, fYEnd + 0.5f, nColor|UI.nOpacityForeground);
-                                ++nNumLines;
                            }
                        }
                        nStackPos--;
@@ -217,7 +217,7 @@ else()
 endif()

 target_link_libraries(audio_core PUBLIC common core)
-if (ARCHITECTURE_x86_64)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
    target_link_libraries(audio_core PRIVATE dynarmic)
 endif()

@@ -226,6 +226,10 @@ if(ENABLE_CUBEB)
    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
 if(ENABLE_SDL2)
-    target_link_libraries(audio_core PRIVATE SDL2)
+    if (YUZU_USE_EXTERNAL_SDL2)
+        target_link_libraries(audio_core PRIVATE SDL2-static)
+    else()
+        target_link_libraries(audio_core PRIVATE SDL2)
+    endif()
    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
@@ -460,21 +460,23 @@ void CommandBuffer::GenerateDeviceSinkCommand(const s32 node_id, const s16 buffe

    cmd.session_id = session_id;

+    cmd.input_count = parameter.input_count;
+    s16 max_input{0};
+    for (u32 i = 0; i < parameter.input_count; i++) {
+        cmd.inputs[i] = buffer_offset + parameter.inputs[i];
+        max_input = std::max(max_input, cmd.inputs[i]);
+    }
+
    if (state.upsampler_info != nullptr) {
        const auto size_{state.upsampler_info->sample_count * parameter.input_count};
        const auto size_bytes{size_ * sizeof(s32)};
        const auto addr{memory_pool->Translate(state.upsampler_info->samples_pos, size_bytes)};
        cmd.sample_buffer = {reinterpret_cast<s32*>(addr),
-                             parameter.input_count * state.upsampler_info->sample_count};
+                             (max_input + 1) * state.upsampler_info->sample_count};
    } else {
        cmd.sample_buffer = samples_buffer;
    }

-    cmd.input_count = parameter.input_count;
-    for (u32 i = 0; i < parameter.input_count; i++) {
-        cmd.inputs[i] = buffer_offset + parameter.inputs[i];
-    }
-
    GenerateEnd<DeviceSinkCommand>(cmd);
 }

@@ -26,6 +26,7 @@ void PerformanceManager::CreateImpl(const size_t version) {
        impl = std::make_unique<
            PerformanceManagerImpl<PerformanceVersion::Version1, PerformanceFrameHeaderVersion1,
                                   PerformanceEntryVersion1, PerformanceDetailVersion1>>();
+        break;
    }
 }

@@ -266,19 +266,20 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
 }

 void SinkStream::Stall() {
-    if (stalled) {
+    std::scoped_lock lk{stall_guard};
+    if (stalled_lock) {
        return;
    }
-    stalled = true;
-    system.StallProcesses();
+    stalled_lock = system.StallProcesses();
 }

 void SinkStream::Unstall() {
-    if (!stalled) {
+    std::scoped_lock lk{stall_guard};
+    if (!stalled_lock) {
        return;
    }
    system.UnstallProcesses();
-    stalled = false;
+    stalled_lock.unlock();
 }

 } // namespace AudioCore::Sink
@@ -6,6 +6,7 @@
 #include <array>
 #include <atomic>
 #include <memory>
+#include <mutex>
 #include <span>
 #include <vector>

@@ -240,8 +241,8 @@ private:
    f32 system_volume{1.0f};
    /// Set via IAudioDevice service calls
    f32 device_volume{1.0f};
-    /// True if coretiming has been stalled
-    bool stalled{false};
+    std::mutex stall_guard;
+    std::unique_lock<std::mutex> stalled_lock;
 };

 using SinkStreamPtr = std::unique_ptr<SinkStream>;
@@ -34,6 +34,8 @@ add_library(common STATIC
    bit_util.h
    cityhash.cpp
    cityhash.h
+    cache_management.cpp
+    cache_management.h
    common_funcs.h
    common_types.h
    concepts.h
@@ -156,6 +156,7 @@ AE_FORCEINLINE void compiler_fence(memory_order order) AE_NO_TSAN {
        break;
    default:
        assert(false);
+        break;
    }
 }

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cstdint>
+#include <cstring>
+
+#include "common/cache_management.h"
+
+namespace Common {
+
+#if defined(ARCHITECTURE_x86_64)
+
+// Most cache operations are no-ops on x86
+
+void DataCacheLineCleanByVAToPoU(void* start, size_t size) {}
+void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size) {}
+void DataCacheLineCleanByVAToPoC(void* start, size_t size) {}
+void DataCacheZeroByVA(void* start, size_t size) {
+    std::memset(start, 0, size);
+}
+
+#elif defined(ARCHITECTURE_arm64)
+
+// BS/DminLine is log2(cache size in words), we want size in bytes
+#define EXTRACT_DMINLINE(ctr_el0) (1 << ((((ctr_el0) >> 16) & 0xf) + 2))
+#define EXTRACT_BS(dczid_el0) (1 << (((dczid_el0)&0xf) + 2))
+
+#define DEFINE_DC_OP(op_name, function_name)                                                       \
+    void function_name(void* start, size_t size) {                                                 \
+        size_t ctr_el0;                                                                            \
+        asm volatile("mrs %[ctr_el0], ctr_el0\n\t" : [ctr_el0] "=r"(ctr_el0));                     \
+        size_t cacheline_size = EXTRACT_DMINLINE(ctr_el0);                                         \
+        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
+        uintptr_t va_end = va_start + size;                                                        \
+        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
+            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
+        }                                                                                          \
+    }
+
+#define DEFINE_DC_OP_DCZID(op_name, function_name)                                                 \
+    void function_name(void* start, size_t size) {                                                 \
+        size_t dczid_el0;                                                                          \
+        asm volatile("mrs %[dczid_el0], dczid_el0\n\t" : [dczid_el0] "=r"(dczid_el0));             \
+        size_t cacheline_size = EXTRACT_BS(dczid_el0);                                             \
+        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
+        uintptr_t va_end = va_start + size;                                                        \
+        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
+            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
+        }                                                                                          \
+    }
+
+DEFINE_DC_OP(cvau, DataCacheLineCleanByVAToPoU);
+DEFINE_DC_OP(civac, DataCacheLineCleanAndInvalidateByVAToPoC);
+DEFINE_DC_OP(cvac, DataCacheLineCleanByVAToPoC);
+DEFINE_DC_OP_DCZID(zva, DataCacheZeroByVA);
+
+#endif
+
+} // namespace Common
@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <cstddef>
+
+namespace Common {
+
+// Data cache instructions enabled at EL0 by SCTLR_EL1.UCI.
+// VA = virtual address
+// PoC = point of coherency
+// PoU = point of unification
+
+// dc cvau
+void DataCacheLineCleanByVAToPoU(void* start, size_t size);
+
+// dc civac
+void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size);
+
+// dc cvac
+void DataCacheLineCleanByVAToPoC(void* start, size_t size);
+
+// dc zva
+void DataCacheZeroByVA(void* start, size_t size);
+
+} // namespace Common
@@ -31,8 +31,10 @@

 #ifndef _MSC_VER

-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64)
 #define Crash() __asm__ __volatile__("int $3")
+#elif defined(ARCHITECTURE_arm64)
+#define Crash() __asm__ __volatile__("brk #0")
 #else
 #define Crash() exit(1)
 #endif
@@ -359,6 +359,12 @@ public:
            }
        });

+        long page_size = sysconf(_SC_PAGESIZE);
+        if (page_size != 0x1000) {
+            LOG_CRITICAL(HW_Memory, "page size {:#x} is incompatible with 4K paging", page_size);
+            throw std::bad_alloc{};
+        }
+
        // Backing memory initialization
 #if defined(__FreeBSD__) && __FreeBSD__ < 13
        // XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30
@@ -383,6 +383,16 @@ void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDevic
    }
 }

+inline void RegisterInputFactory(const std::string& name,
+                                 std::shared_ptr<Factory<InputDevice>> factory) {
+    RegisterFactory<InputDevice>(name, std::move(factory));
+}
+
+inline void RegisterOutputFactory(const std::string& name,
+                                  std::shared_ptr<Factory<OutputDevice>> factory) {
+    RegisterFactory<OutputDevice>(name, std::move(factory));
+}
+
 /**
 * Unregisters an input device factory.
 * @tparam InputDeviceType the type of input devices the factory can create
@@ -395,6 +405,14 @@ void UnregisterFactory(const std::string& name) {
    }
 }

+inline void UnregisterInputFactory(const std::string& name) {
+    UnregisterFactory<InputDevice>(name);
+}
+
+inline void UnregisterOutputFactory(const std::string& name) {
+    UnregisterFactory<OutputDevice>(name);
+}
+
 /**
 * Create an input device from given paramters.
 * @tparam InputDeviceType the type of input devices to create
@@ -416,13 +434,21 @@ std::unique_ptr<InputDeviceType> CreateDeviceFromString(const std::string& param
    return pair->second->Create(package);
 }

+inline std::unique_ptr<InputDevice> CreateInputDeviceFromString(const std::string& params) {
+    return CreateDeviceFromString<InputDevice>(params);
+}
+
+inline std::unique_ptr<OutputDevice> CreateOutputDeviceFromString(const std::string& params) {
+    return CreateDeviceFromString<OutputDevice>(params);
+}
+
 /**
- * Create an input device from given paramters.
+ * Create an input device from given parameters.
 * @tparam InputDeviceType the type of input devices to create
- * @param A ParamPackage that contains all parameters for creating the device
+ * @param package A ParamPackage that contains all parameters for creating the device
 */
 template <typename InputDeviceType>
-std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package) {
+std::unique_ptr<InputDeviceType> CreateDevice(const ParamPackage& package) {
    const std::string engine = package.Get("engine", "null");
    const auto& factory_list = Impl::FactoryList<InputDeviceType>::list;
    const auto pair = factory_list.find(engine);
@@ -435,4 +461,12 @@ std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package
    return pair->second->Create(package);
 }

+inline std::unique_ptr<InputDevice> CreateInputDevice(const ParamPackage& package) {
+    return CreateDevice<InputDevice>(package);
+}
+
+inline std::unique_ptr<OutputDevice> CreateOutputDevice(const ParamPackage& package) {
+    return CreateDevice<OutputDevice>(package);
+}
+
 } // namespace Common::Input
@@ -48,6 +48,7 @@ void LogSettings() {
    log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
    log_setting("Renderer_UseResolutionScaling", values.resolution_setup.GetValue());
    log_setting("Renderer_ScalingFilter", values.scaling_filter.GetValue());
+    log_setting("Renderer_FSRSlider", values.fsr_sharpening_slider.GetValue());
    log_setting("Renderer_AntiAliasing", values.anti_aliasing.GetValue());
    log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
    log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
@@ -151,6 +152,7 @@ void UpdateRescalingInfo() {
        ASSERT(false);
        info.up_scale = 1;
        info.down_shift = 0;
+        break;
    }
    info.up_factor = static_cast<f32>(info.up_scale) / (1U << info.down_shift);
    info.down_factor = static_cast<f32>(1U << info.down_shift) / info.up_scale;
@@ -180,6 +182,7 @@ void RestoreGlobalState(bool is_powered_on) {
    values.cpuopt_unsafe_ignore_global_monitor.SetGlobal(true);

    // Renderer
+    values.fsr_sharpening_slider.SetGlobal(true);
    values.renderer_backend.SetGlobal(true);
    values.vulkan_device.SetGlobal(true);
    values.aspect_ratio.SetGlobal(true);
@@ -421,6 +421,7 @@ struct Values {
    ResolutionScalingInfo resolution_info{};
    SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
    SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
+    SwitchableSetting<int, true> fsr_sharpening_slider{25, 0, 200, "fsr_sharpening_slider"};
    SwitchableSetting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
    // *nix platforms may have issues with the borderless windowed fullscreen mode.
    // Default to exclusive fullscreen on these platforms for now.
@@ -442,7 +443,7 @@ struct Values {
    SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
    SwitchableSetting<bool> accelerate_astc{true, "accelerate_astc"};
    SwitchableSetting<bool> use_vsync{true, "use_vsync"};
-    SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
+    SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLSL, ShaderBackend::GLSL,
                                                          ShaderBackend::SPIRV, "shader_backend"};
    SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
    SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
@@ -4,14 +4,27 @@

 #include <array>
 #include <cstring>
+#include <fstream>
 #include <iterator>
+#include <optional>
 #include <string_view>
+#include <thread>
+#include <vector>
 #include "common/bit_util.h"
 #include "common/common_types.h"
+#include "common/logging/log.h"
 #include "common/x64/cpu_detect.h"

+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 #ifdef _MSC_VER
 #include <intrin.h>
+
+static inline u64 xgetbv(u32 index) {
+    return _xgetbv(index);
+}
 #else

 #if defined(__DragonFly__) || defined(__FreeBSD__)
@@ -39,12 +52,11 @@ static inline void __cpuid(int info[4], u32 function_id) {
 }

 #define _XCR_XFEATURE_ENABLED_MASK 0
-static inline u64 _xgetbv(u32 index) {
+static inline u64 xgetbv(u32 index) {
    u32 eax, edx;
    __asm__ __volatile__("xgetbv" : "=a"(eax), "=d"(edx) : "c"(index));
    return ((u64)edx << 32) | eax;
 }
-
 #endif // _MSC_VER

 namespace Common {
@@ -107,7 +119,7 @@ static CPUCaps Detect() {
        //  - Is the XSAVE bit set in CPUID?
        //  - XGETBV result has the XCR bit set.
        if (Common::Bit<28>(cpu_id[2]) && Common::Bit<27>(cpu_id[2])) {
-            if ((_xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6) {
+            if ((xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6) {
                caps.avx = true;
                if (Common::Bit<12>(cpu_id[2]))
                    caps.fma = true;
@@ -192,4 +204,45 @@ const CPUCaps& GetCPUCaps() {
    return caps;
 }

+std::optional<int> GetProcessorCount() {
+#if defined(_WIN32)
+    // Get the buffer length.
+    DWORD length = 0;
+    GetLogicalProcessorInformation(nullptr, &length);
+    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+        LOG_ERROR(Frontend, "Failed to query core count.");
+        return std::nullopt;
+    }
+    std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(
+        length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION));
+    // Now query the core count.
+    if (!GetLogicalProcessorInformation(buffer.data(), &length)) {
+        LOG_ERROR(Frontend, "Failed to query core count.");
+        return std::nullopt;
+    }
+    return static_cast<int>(
+        std::count_if(buffer.cbegin(), buffer.cend(), [](const auto& proc_info) {
+            return proc_info.Relationship == RelationProcessorCore;
+        }));
+#elif defined(__unix__)
+    const int thread_count = std::thread::hardware_concurrency();
+    std::ifstream smt("/sys/devices/system/cpu/smt/active");
+    char state = '0';
+    if (smt) {
+        smt.read(&state, sizeof(state));
+    }
+    switch (state) {
+    case '0':
+        return thread_count;
+    case '1':
+        return thread_count / 2;
+    default:
+        return std::nullopt;
+    }
+#else
+    // Shame on you
+    return std::nullopt;
+#endif
+}
+
 } // namespace Common
@@ -4,6 +4,7 @@

 #pragma once

+#include <optional>
 #include <string_view>
 #include "common/common_types.h"

@@ -74,4 +75,7 @@ struct CPUCaps {
 */
 const CPUCaps& GetCPUCaps();

+/// Detects CPU core count
+std::optional<int> GetProcessorCount();
+
 } // namespace Common
@@ -120,6 +120,8 @@ add_library(core STATIC
    file_sys/vfs_vector.h
    file_sys/xts_archive.cpp
    file_sys/xts_archive.h
+    frontend/applets/cabinet.cpp
+    frontend/applets/cabinet.h
    frontend/applets/controller.cpp
    frontend/applets/controller.h
    frontend/applets/error.cpp
@@ -312,6 +314,8 @@ add_library(core STATIC
    hle/service/am/applet_ae.h
    hle/service/am/applet_oe.cpp
    hle/service/am/applet_oe.h
+    hle/service/am/applets/applet_cabinet.cpp
+    hle/service/am/applets/applet_cabinet.h
    hle/service/am/applets/applet_controller.cpp
    hle/service/am/applets/applet_controller.h
    hle/service/am/applets/applet_error.cpp
@@ -497,10 +501,6 @@ add_library(core STATIC
    hle/service/hid/irsensor/processor_base.h
    hle/service/hid/irsensor/tera_plugin_processor.cpp
    hle/service/hid/irsensor/tera_plugin_processor.h
-    hle/service/jit/jit_context.cpp
-    hle/service/jit/jit_context.h
-    hle/service/jit/jit.cpp
-    hle/service/jit/jit.h
    hle/service/lbl/lbl.cpp
    hle/service/lbl/lbl.h
    hle/service/ldn/lan_discovery.cpp
@@ -530,6 +530,11 @@ add_library(core STATIC
    hle/service/ncm/ncm.h
    hle/service/nfc/nfc.cpp
    hle/service/nfc/nfc.h
+    hle/service/nfc/nfc_device.cpp
+    hle/service/nfc/nfc_device.h
+    hle/service/nfc/nfc_result.h
+    hle/service/nfc/nfc_user.cpp
+    hle/service/nfc/nfc_user.h
    hle/service/nfp/amiibo_crypto.cpp
    hle/service/nfp/amiibo_crypto.h
    hle/service/nfp/nfp.cpp
@@ -805,14 +810,18 @@ if (ENABLE_WEB_SERVICE)
    target_link_libraries(core PRIVATE web_service)
 endif()

-if (ARCHITECTURE_x86_64)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
    target_sources(core PRIVATE
-        arm/dynarmic/arm_dynarmic_32.cpp
-        arm/dynarmic/arm_dynarmic_32.h
        arm/dynarmic/arm_dynarmic_64.cpp
        arm/dynarmic/arm_dynarmic_64.h
+        arm/dynarmic/arm_dynarmic_32.cpp
+        arm/dynarmic/arm_dynarmic_32.h
        arm/dynarmic/arm_dynarmic_cp15.cpp
        arm/dynarmic/arm_dynarmic_cp15.h
+        hle/service/jit/jit_context.cpp
+        hle/service/jit/jit_context.h
+        hle/service/jit/jit.cpp
+        hle/service/jit/jit.h
    )
    target_link_libraries(core PRIVATE dynarmic)
 endif()
@@ -301,6 +301,11 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
        }
    }

+#ifdef ARCHITECTURE_arm64
+    // TODO: remove when fixed in dynarmic
+    config.optimizations &= ~Dynarmic::OptimizationFlag::BlockLinking;
+#endif
+
    return std::make_unique<Dynarmic::A32::Jit>(config);
 }

@@ -348,7 +348,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
        if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
            config.unsafe_optimizations = true;
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
            config.fastmem_address_space_bits = 64;
            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
        }
@@ -52,12 +52,16 @@ CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1
        case 4:
            // CP15_DATA_SYNC_BARRIER
            return Callback{
-                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
-#ifdef _MSC_VER
+                [](void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#if defined(_MSC_VER) && defined(ARCHITECTURE_x86_64)
                    _mm_mfence();
                    _mm_lfence();
-#else
+#elif defined(ARCHITECTURE_x86_64)
                    asm volatile("mfence\n\tlfence\n\t" : : : "memory");
+#elif defined(ARCHITECTURE_arm64)
+                    asm volatile("dsb sy\n\t" : : : "memory");
+#else
+#error Unsupported architecture
 #endif
                    return 0;
                },
@@ -66,11 +70,15 @@ CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1
        case 5:
            // CP15_DATA_MEMORY_BARRIER
            return Callback{
-                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
-#ifdef _MSC_VER
+                [](void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#if defined(_MSC_VER) && defined(ARCHITECTURE_x86_64)
                    _mm_mfence();
-#else
+#elif defined(ARCHITECTURE_x86_64)
                    asm volatile("mfence\n\t" : : : "memory");
+#elif defined(ARCHITECTURE_arm64)
+                    asm volatile("dmb sy\n\t" : : : "memory");
+#else
+#error Unsupported architecture
 #endif
                    return 0;
                },
@@ -115,7 +123,7 @@ CallbackOrAccessOneWord DynarmicCP15::CompileGetOneWord(bool two, unsigned opc1,
 CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) {
    if (!two && opc == 0 && CRm == CoprocReg::C14) {
        // CNTPCT
-        const auto callback = [](Dynarmic::A32::Jit*, void* arg, u32, u32) -> u64 {
+        const auto callback = [](void* arg, u32, u32) -> u64 {
            const auto& parent_arg = *static_cast<ARM_Dynarmic_32*>(arg);
            return parent_arg.system.CoreTiming().GetClockTicks();
        };
@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #endif
 #include "core/arm/exclusive_monitor.h"
@@ -13,7 +13,7 @@ ExclusiveMonitor::~ExclusiveMonitor() = default;

 std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
                                                             std::size_t num_cores) {
-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
    return std::make_unique<Core::DynarmicExclusiveMonitor>(memory, num_cores);
 #else
    // TODO(merry): Passthrough exclusive monitor
@@ -189,7 +189,7 @@ struct System::Impl {

        kernel.Suspend(false);
        core_timing.SyncPause(false);
-        is_paused = false;
+        is_paused.store(false, std::memory_order_relaxed);

        return status;
    }
@@ -200,14 +200,13 @@ struct System::Impl {

        core_timing.SyncPause(true);
        kernel.Suspend(true);
-        is_paused = true;
+        is_paused.store(true, std::memory_order_relaxed);

        return status;
    }

    bool IsPaused() const {
-        std::unique_lock lk(suspend_guard);
-        return is_paused;
+        return is_paused.load(std::memory_order_relaxed);
    }

    std::unique_lock<std::mutex> StallProcesses() {
@@ -218,7 +217,7 @@ struct System::Impl {
    }

    void UnstallProcesses() {
-        if (!is_paused) {
+        if (!IsPaused()) {
            core_timing.SyncPause(false);
            kernel.Suspend(false);
        }
@@ -465,7 +464,7 @@ struct System::Impl {
    }

    mutable std::mutex suspend_guard;
-    bool is_paused{};
+    std::atomic_bool is_paused{};
    std::atomic<bool> is_shutting_down{};

    Timing::CoreTiming core_timing;
@@ -578,18 +578,18 @@ KeyManager::KeyManager() {

    if (Settings::values.use_dev_keys) {
        dev_mode = true;
-        LoadFromFile(yuzu_keys_dir / "dev.keys", false);
        LoadFromFile(yuzu_keys_dir / "dev.keys_autogenerated", false);
+        LoadFromFile(yuzu_keys_dir / "dev.keys", false);
    } else {
        dev_mode = false;
-        LoadFromFile(yuzu_keys_dir / "prod.keys", false);
        LoadFromFile(yuzu_keys_dir / "prod.keys_autogenerated", false);
+        LoadFromFile(yuzu_keys_dir / "prod.keys", false);
    }

-    LoadFromFile(yuzu_keys_dir / "title.keys", true);
    LoadFromFile(yuzu_keys_dir / "title.keys_autogenerated", true);
-    LoadFromFile(yuzu_keys_dir / "console.keys", false);
+    LoadFromFile(yuzu_keys_dir / "title.keys", true);
    LoadFromFile(yuzu_keys_dir / "console.keys_autogenerated", false);
+    LoadFromFile(yuzu_keys_dir / "console.keys", false);
 }

 static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_t length) {
@@ -27,12 +27,21 @@ static void AsyncReceiveInto(Readable& r, Buffer& buffer, Callback&& c) {
                const u8* buffer_start = reinterpret_cast<const u8*>(&buffer);
                std::span<const u8> received_data{buffer_start, buffer_start + bytes_read};
                c(received_data);
+                AsyncReceiveInto(r, buffer, c);
            }
-
-            AsyncReceiveInto(r, buffer, c);
        });
 }

+template <typename Callback>
+static void AsyncAccept(boost::asio::ip::tcp::acceptor& acceptor, Callback&& c) {
+    acceptor.async_accept([&, c](const boost::system::error_code& error, auto&& peer_socket) {
+        if (!error.failed()) {
+            c(peer_socket);
+            AsyncAccept(acceptor, c);
+        }
+    });
+}
+
 template <typename Readable, typename Buffer>
 static std::span<const u8> ReceiveInto(Readable& r, Buffer& buffer) {
    static_assert(std::is_trivial_v<Buffer>);
@@ -59,9 +68,7 @@ namespace Core {

 class DebuggerImpl : public DebuggerBackend {
 public:
-    explicit DebuggerImpl(Core::System& system_, u16 port)
-        : system{system_}, signal_pipe{io_context}, client_socket{io_context} {
-        frontend = std::make_unique<GDBStub>(*this, system);
+    explicit DebuggerImpl(Core::System& system_, u16 port) : system{system_} {
        InitializeServer(port);
    }

@@ -70,39 +77,42 @@ public:
    }

    bool SignalDebugger(SignalInfo signal_info) {
-        {
-            std::scoped_lock lk{connection_lock};
+        std::scoped_lock lk{connection_lock};

-            if (stopped) {
-                // Do not notify the debugger about another event.
-                // It should be ignored.
-                return false;
-            }
-
-            // Set up the state.
-            stopped = true;
-            info = signal_info;
+        if (stopped || !state) {
+            // Do not notify the debugger about another event.
+            // It should be ignored.
+            return false;
        }

+        // Set up the state.
+        stopped = true;
+        state->info = signal_info;
+
        // Write a single byte into the pipe to wake up the debug interface.
-        boost::asio::write(signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
+        boost::asio::write(state->signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
+
        return true;
    }

+    // These functions are callbacks from the frontend, and the lock will be held.
+    // There is no need to relock it.
+
    std::span<const u8> ReadFromClient() override {
-        return ReceiveInto(client_socket, client_data);
+        return ReceiveInto(state->client_socket, state->client_data);
    }

    void WriteToClient(std::span<const u8> data) override {
-        boost::asio::write(client_socket, boost::asio::buffer(data.data(), data.size_bytes()));
+        boost::asio::write(state->client_socket,
+                           boost::asio::buffer(data.data(), data.size_bytes()));
    }

    void SetActiveThread(Kernel::KThread* thread) override {
-        active_thread = thread;
+        state->active_thread = thread;
    }

    Kernel::KThread* GetActiveThread() override {
-        return active_thread;
+        return state->active_thread;
    }

 private:
@@ -113,65 +123,78 @@ private:

        // Run the connection thread.
        connection_thread = std::jthread([&, port](std::stop_token stop_token) {
+            Common::SetCurrentThreadName("Debugger");
+
            try {
                // Initialize the listening socket and accept a new client.
                tcp::endpoint endpoint{boost::asio::ip::address_v4::any(), port};
                tcp::acceptor acceptor{io_context, endpoint};

-                acceptor.async_accept(client_socket, [](const auto&) {});
-                io_context.run_one();
-                io_context.restart();
+                AsyncAccept(acceptor, [&](auto&& peer) { AcceptConnection(std::move(peer)); });

-                if (stop_token.stop_requested()) {
-                    return;
+                while (!stop_token.stop_requested() && io_context.run()) {
                }
-
-                ThreadLoop(stop_token);
            } catch (const std::exception& ex) {
                LOG_CRITICAL(Debug_GDBStub, "Stopping server: {}", ex.what());
            }
        });
    }

+    void AcceptConnection(boost::asio::ip::tcp::socket&& peer) {
+        LOG_INFO(Debug_GDBStub, "Accepting new peer connection");
+
+        std::scoped_lock lk{connection_lock};
+
+        // Ensure everything is stopped.
+        PauseEmulation();
+
+        // Set up the new frontend.
+        frontend = std::make_unique<GDBStub>(*this, system);
+
+        // Set the new state. This will tear down any existing state.
+        state = ConnectionState{
+            .client_socket{std::move(peer)},
+            .signal_pipe{io_context},
+            .info{},
+            .active_thread{},
+            .client_data{},
+            .pipe_data{},
+        };
+
+        // Set up the client signals for new data.
+        AsyncReceiveInto(state->signal_pipe, state->pipe_data, [&](auto d) { PipeData(d); });
+        AsyncReceiveInto(state->client_socket, state->client_data, [&](auto d) { ClientData(d); });
+
+        // Set the active thread.
+        UpdateActiveThread();
+
+        // Set up the frontend.
+        frontend->Connected();
+    }
+
    void ShutdownServer() {
        connection_thread.request_stop();
        io_context.stop();
        connection_thread.join();
    }

-    void ThreadLoop(std::stop_token stop_token) {
-        Common::SetCurrentThreadName("Debugger");
-
-        // Set up the client signals for new data.
-        AsyncReceiveInto(signal_pipe, pipe_data, [&](auto d) { PipeData(d); });
-        AsyncReceiveInto(client_socket, client_data, [&](auto d) { ClientData(d); });
-
-        // Set the active thread.
-        UpdateActiveThread();
-
-        // Set up the frontend.
-        frontend->Connected();
-
-        // Main event loop.
-        while (!stop_token.stop_requested() && io_context.run()) {
-        }
-    }
-
    void PipeData(std::span<const u8> data) {
-        switch (info.type) {
+        std::scoped_lock lk{connection_lock};
+
+        switch (state->info.type) {
        case SignalType::Stopped:
        case SignalType::Watchpoint:
            // Stop emulation.
            PauseEmulation();

            // Notify the client.
-            active_thread = info.thread;
+            state->active_thread = state->info.thread;
            UpdateActiveThread();

-            if (info.type == SignalType::Watchpoint) {
-                frontend->Watchpoint(active_thread, *info.watchpoint);
+            if (state->info.type == SignalType::Watchpoint) {
+                frontend->Watchpoint(state->active_thread, *state->info.watchpoint);
            } else {
-                frontend->Stopped(active_thread);
+                frontend->Stopped(state->active_thread);
            }

            break;
@@ -179,8 +202,8 @@ private:
            frontend->ShuttingDown();

            // Wait for emulation to shut down gracefully now.
-            signal_pipe.close();
-            client_socket.shutdown(boost::asio::socket_base::shutdown_both);
+            state->signal_pipe.close();
+            state->client_socket.shutdown(boost::asio::socket_base::shutdown_both);
            LOG_INFO(Debug_GDBStub, "Shut down server");

            break;
@@ -188,17 +211,16 @@ private:
    }

    void ClientData(std::span<const u8> data) {
+        std::scoped_lock lk{connection_lock};
+
        const auto actions{frontend->ClientData(data)};
        for (const auto action : actions) {
            switch (action) {
            case DebuggerAction::Interrupt: {
-                {
-                    std::scoped_lock lk{connection_lock};
-                    stopped = true;
-                }
+                stopped = true;
                PauseEmulation();
                UpdateActiveThread();
-                frontend->Stopped(active_thread);
+                frontend->Stopped(state->active_thread);
                break;
            }
            case DebuggerAction::Continue:
@@ -206,15 +228,15 @@ private:
                break;
            case DebuggerAction::StepThreadUnlocked:
                MarkResumed([&] {
-                    active_thread->SetStepState(Kernel::StepState::StepPending);
-                    active_thread->Resume(Kernel::SuspendType::Debug);
-                    ResumeEmulation(active_thread);
+                    state->active_thread->SetStepState(Kernel::StepState::StepPending);
+                    state->active_thread->Resume(Kernel::SuspendType::Debug);
+                    ResumeEmulation(state->active_thread);
                });
                break;
            case DebuggerAction::StepThreadLocked: {
                MarkResumed([&] {
-                    active_thread->SetStepState(Kernel::StepState::StepPending);
-                    active_thread->Resume(Kernel::SuspendType::Debug);
+                    state->active_thread->SetStepState(Kernel::StepState::StepPending);
+                    state->active_thread->Resume(Kernel::SuspendType::Debug);
                });
                break;
            }
@@ -254,15 +276,14 @@ private:
    template <typename Callback>
    void MarkResumed(Callback&& cb) {
        Kernel::KScopedSchedulerLock sl{system.Kernel()};
-        std::scoped_lock cl{connection_lock};
        stopped = false;
        cb();
    }

    void UpdateActiveThread() {
        const auto& threads{ThreadList()};
-        if (std::find(threads.begin(), threads.end(), active_thread) == threads.end()) {
-            active_thread = threads[0];
+        if (std::find(threads.begin(), threads.end(), state->active_thread) == threads.end()) {
+            state->active_thread = threads[0];
        }
    }

@@ -274,18 +295,22 @@ private:
    System& system;
    std::unique_ptr<DebuggerFrontend> frontend;

+    boost::asio::io_context io_context;
    std::jthread connection_thread;
    std::mutex connection_lock;
-    boost::asio::io_context io_context;
-    boost::process::async_pipe signal_pipe;
-    boost::asio::ip::tcp::socket client_socket;

-    SignalInfo info;
-    Kernel::KThread* active_thread;
-    bool pipe_data;
-    bool stopped;
+    struct ConnectionState {
+        boost::asio::ip::tcp::socket client_socket;
+        boost::process::async_pipe signal_pipe;

-    std::array<u8, 4096> client_data;
+        SignalInfo info;
+        Kernel::KThread* active_thread;
+        std::array<u8, 4096> client_data;
+        bool pipe_data;
+    };
+
+    std::optional<ConnectionState> state{};
+    bool stopped{};
 };

 Debugger::Debugger(Core::System& system, u16 port) {
@@ -606,6 +606,8 @@ void GDBStub::HandleQuery(std::string_view command) {
    } else if (command.starts_with("StartNoAckMode")) {
        no_ack = true;
        SendReply(GDB_STUB_REPLY_OK);
+    } else if (command.starts_with("Rcmd,")) {
+        HandleRcmd(Common::HexStringToVector(command.substr(5), false));
    } else {
        SendReply(GDB_STUB_REPLY_EMPTY);
    }
@@ -645,6 +647,155 @@ void GDBStub::HandleVCont(std::string_view command, std::vector<DebuggerAction>&
    }
 }

+constexpr std::array<std::pair<const char*, Kernel::Svc::MemoryState>, 22> MemoryStateNames{{
+    {"----- Free -----", Kernel::Svc::MemoryState::Free},
+    {"Io              ", Kernel::Svc::MemoryState::Io},
+    {"Static          ", Kernel::Svc::MemoryState::Static},
+    {"Code            ", Kernel::Svc::MemoryState::Code},
+    {"CodeData        ", Kernel::Svc::MemoryState::CodeData},
+    {"Normal          ", Kernel::Svc::MemoryState::Normal},
+    {"Shared          ", Kernel::Svc::MemoryState::Shared},
+    {"AliasCode       ", Kernel::Svc::MemoryState::AliasCode},
+    {"AliasCodeData   ", Kernel::Svc::MemoryState::AliasCodeData},
+    {"Ipc             ", Kernel::Svc::MemoryState::Ipc},
+    {"Stack           ", Kernel::Svc::MemoryState::Stack},
+    {"ThreadLocal     ", Kernel::Svc::MemoryState::ThreadLocal},
+    {"Transfered      ", Kernel::Svc::MemoryState::Transfered},
+    {"SharedTransfered", Kernel::Svc::MemoryState::SharedTransfered},
+    {"SharedCode      ", Kernel::Svc::MemoryState::SharedCode},
+    {"Inaccessible    ", Kernel::Svc::MemoryState::Inaccessible},
+    {"NonSecureIpc    ", Kernel::Svc::MemoryState::NonSecureIpc},
+    {"NonDeviceIpc    ", Kernel::Svc::MemoryState::NonDeviceIpc},
+    {"Kernel          ", Kernel::Svc::MemoryState::Kernel},
+    {"GeneratedCode   ", Kernel::Svc::MemoryState::GeneratedCode},
+    {"CodeOut         ", Kernel::Svc::MemoryState::CodeOut},
+    {"Coverage        ", Kernel::Svc::MemoryState::Coverage},
+}};
+
+static constexpr const char* GetMemoryStateName(Kernel::Svc::MemoryState state) {
+    for (size_t i = 0; i < MemoryStateNames.size(); i++) {
+        if (std::get<1>(MemoryStateNames[i]) == state) {
+            return std::get<0>(MemoryStateNames[i]);
+        }
+    }
+    return "Unknown         ";
+}
+
+static constexpr const char* GetMemoryPermissionString(const Kernel::Svc::MemoryInfo& info) {
+    if (info.state == Kernel::Svc::MemoryState::Free) {
+        return "   ";
+    }
+
+    switch (info.permission) {
+    case Kernel::Svc::MemoryPermission::ReadExecute:
+        return "r-x";
+    case Kernel::Svc::MemoryPermission::Read:
+        return "r--";
+    case Kernel::Svc::MemoryPermission::ReadWrite:
+        return "rw-";
+    default:
+        return "---";
+    }
+}
+
+static VAddr GetModuleEnd(Kernel::KPageTable& page_table, VAddr base) {
+    Kernel::Svc::MemoryInfo mem_info;
+    VAddr cur_addr{base};
+
+    // Expect: r-x Code (.text)
+    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+    cur_addr = mem_info.base_address + mem_info.size;
+    if (mem_info.state != Kernel::Svc::MemoryState::Code ||
+        mem_info.permission != Kernel::Svc::MemoryPermission::ReadExecute) {
+        return cur_addr - 1;
+    }
+
+    // Expect: r-- Code (.rodata)
+    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+    cur_addr = mem_info.base_address + mem_info.size;
+    if (mem_info.state != Kernel::Svc::MemoryState::Code ||
+        mem_info.permission != Kernel::Svc::MemoryPermission::Read) {
+        return cur_addr - 1;
+    }
+
+    // Expect: rw- CodeData (.data)
+    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+    cur_addr = mem_info.base_address + mem_info.size;
+    return cur_addr - 1;
+}
+
+void GDBStub::HandleRcmd(const std::vector<u8>& command) {
+    std::string_view command_str{reinterpret_cast<const char*>(&command[0]), command.size()};
+    std::string reply;
+
+    auto* process = system.CurrentProcess();
+    auto& page_table = process->PageTable();
+
+    if (command_str == "get info") {
+        Loader::AppLoader::Modules modules;
+        system.GetAppLoader().ReadNSOModules(modules);
+
+        reply = fmt::format("Process:     {:#x} ({})\n"
+                            "Program Id:  {:#018x}\n",
+                            process->GetProcessID(), process->GetName(), process->GetProgramID());
+        reply +=
+            fmt::format("Layout:\n"
+                        "  Alias: {:#012x} - {:#012x}\n"
+                        "  Heap:  {:#012x} - {:#012x}\n"
+                        "  Aslr:  {:#012x} - {:#012x}\n"
+                        "  Stack: {:#012x} - {:#012x}\n"
+                        "Modules:\n",
+                        page_table.GetAliasRegionStart(), page_table.GetAliasRegionEnd(),
+                        page_table.GetHeapRegionStart(), page_table.GetHeapRegionEnd(),
+                        page_table.GetAliasCodeRegionStart(), page_table.GetAliasCodeRegionEnd(),
+                        page_table.GetStackRegionStart(), page_table.GetStackRegionEnd());
+
+        for (const auto& [vaddr, name] : modules) {
+            reply += fmt::format("  {:#012x} - {:#012x} {}\n", vaddr,
+                                 GetModuleEnd(page_table, vaddr), name);
+        }
+    } else if (command_str == "get mappings") {
+        reply = "Mappings:\n";
+        VAddr cur_addr = 0;
+
+        while (true) {
+            using MemoryAttribute = Kernel::Svc::MemoryAttribute;
+
+            auto mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
+
+            if (mem_info.state != Kernel::Svc::MemoryState::Inaccessible ||
+                mem_info.base_address + mem_info.size - 1 != std::numeric_limits<u64>::max()) {
+                const char* state = GetMemoryStateName(mem_info.state);
+                const char* perm = GetMemoryPermissionString(mem_info);
+
+                const char l = True(mem_info.attribute & MemoryAttribute::Locked) ? 'L' : '-';
+                const char i = True(mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
+                const char d = True(mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
+                const char u = True(mem_info.attribute & MemoryAttribute::Uncached) ? 'U' : '-';
+
+                reply +=
+                    fmt::format("  {:#012x} - {:#012x} {} {} {}{}{}{} [{}, {}]\n",
+                                mem_info.base_address, mem_info.base_address + mem_info.size - 1,
+                                perm, state, l, i, d, u, mem_info.ipc_count, mem_info.device_count);
+            }
+
+            const uintptr_t next_address = mem_info.base_address + mem_info.size;
+            if (next_address <= cur_addr) {
+                break;
+            }
+
+            cur_addr = next_address;
+        }
+    } else if (command_str == "help") {
+        reply = "Commands:\n  get info\n  get mappings\n";
+    } else {
+        reply = "Unknown command.\nCommands:\n  get info\n  get mappings\n";
+    }
+
+    std::span<const u8> reply_span{reinterpret_cast<u8*>(&reply.front()), reply.size()};
+    SendReply(Common::HexToString(reply_span, false));
+}
+
 Kernel::KThread* GDBStub::GetThreadByID(u64 thread_id) {
    const auto& threads{system.GlobalSchedulerContext().GetThreadList()};
    for (auto* thread : threads) {
@@ -32,6 +32,7 @@ private:
    void ExecuteCommand(std::string_view packet, std::vector<DebuggerAction>& actions);
    void HandleVCont(std::string_view command, std::vector<DebuggerAction>& actions);
    void HandleQuery(std::string_view command);
+    void HandleRcmd(const std::vector<u8>& command);
    void HandleBreakpointInsert(std::string_view command);
    void HandleBreakpointRemove(std::string_view command);
    std::vector<char>::const_iterator CommandEnd() const;
@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/frontend/applets/cabinet.h"
+
+#include <thread>
+
+namespace Core::Frontend {
+
+CabinetApplet::~CabinetApplet() = default;
+
+void DefaultCabinetApplet::ShowCabinetApplet(
+    const CabinetCallback& callback, const CabinetParameters& parameters,
+    std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+    callback(false, {});
+}
+
+} // namespace Core::Frontend
@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <functional>
+#include "core/hle/service/nfp/nfp_types.h"
+
+namespace Service::NFP {
+class NfpDevice;
+} // namespace Service::NFP
+
+namespace Core::Frontend {
+
+struct CabinetParameters {
+    Service::NFP::TagInfo tag_info;
+    Service::NFP::RegisterInfo register_info;
+    Service::NFP::CabinetMode mode;
+};
+
+using CabinetCallback = std::function<void(bool, const std::string&)>;
+
+class CabinetApplet {
+public:
+    virtual ~CabinetApplet();
+    virtual void ShowCabinetApplet(const CabinetCallback& callback,
+                                   const CabinetParameters& parameters,
+                                   std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const = 0;
+};
+
+class DefaultCabinetApplet final : public CabinetApplet {
+public:
+    void ShowCabinetApplet(const CabinetCallback& callback, const CabinetParameters& parameters,
+                           std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const override;
+};
+
+} // namespace Core::Frontend
@@ -19,27 +19,26 @@ void EmulatedConsole::ReloadFromSettings() {
 }

 void EmulatedConsole::SetTouchParams() {
-    // TODO(german77): Support any number of fingers
    std::size_t index = 0;

-    // Hardcode mouse, touchscreen and cemuhook parameters
+    // We can't use mouse as touch if native mouse is enabled
    if (!Settings::values.mouse_enabled) {
-        // We can't use mouse as touch if native mouse is enabled
        touch_params[index++] = Common::ParamPackage{"engine:mouse,axis_x:10,axis_y:11,button:0"};
    }

    touch_params[index++] =
-        Common::ParamPackage{"engine:touch,axis_x:0,axis_y:1,button:0,touch_id:0"};
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536"};
    touch_params[index++] =
-        Common::ParamPackage{"engine:touch,axis_x:2,axis_y:3,button:1,touch_id:1"};
-    touch_params[index++] =
-        Common::ParamPackage{"engine:touch,axis_x:4,axis_y:5,button:2,touch_id:2"};
-    touch_params[index++] =
-        Common::ParamPackage{"engine:touch,axis_x:6,axis_y:7,button:3,touch_id:3"};
-    touch_params[index++] =
-        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536,touch_id:0"};
-    touch_params[index++] =
-        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072,touch_id:1"};
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072"};
+
+    for (int i = 0; i < static_cast<int>(MaxActiveTouchInputs); i++) {
+        Common::ParamPackage touchscreen_param{};
+        touchscreen_param.Set("engine", "touch");
+        touchscreen_param.Set("axis_x", i * 2);
+        touchscreen_param.Set("axis_y", (i * 2) + 1);
+        touchscreen_param.Set("button", i);
+        touch_params[index++] = touchscreen_param;
+    }

    const auto button_index =
        static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
@@ -47,7 +46,7 @@ void EmulatedConsole::SetTouchParams() {

    // Map the rest of the fingers from touch from button configuration
    for (const auto& config_entry : touch_buttons) {
-        if (index >= touch_params.size()) {
+        if (index >= MaxTouchDevices) {
            continue;
        }
        Common::ParamPackage params{config_entry};
@@ -60,7 +59,6 @@ void EmulatedConsole::SetTouchParams() {
        touch_button_params.Set("button", params.Serialize());
        touch_button_params.Set("x", x);
        touch_button_params.Set("y", y);
-        touch_button_params.Set("touch_id", static_cast<int>(index));
        touch_params[index] = touch_button_params;
        index++;
    }
@@ -70,7 +68,7 @@ void EmulatedConsole::ReloadInput() {
    // If you load any device here add the equivalent to the UnloadInput() function
    SetTouchParams();

-    motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
+    motion_devices = Common::Input::CreateInputDevice(motion_params);
    if (motion_devices) {
        motion_devices->SetCallback({
            .on_change =
@@ -81,7 +79,7 @@ void EmulatedConsole::ReloadInput() {
    // Unique index for identifying touch device source
    std::size_t index = 0;
    for (auto& touch_device : touch_devices) {
-        touch_device = Common::Input::CreateDevice<Common::Input::InputDevice>(touch_params[index]);
+        touch_device = Common::Input::CreateInputDevice(touch_params[index]);
        if (!touch_device) {
            continue;
        }
@@ -178,12 +176,38 @@ void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
 }

 void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index) {
-    if (index >= console.touch_values.size()) {
+    if (index >= MaxTouchDevices) {
        return;
    }
    std::unique_lock lock{mutex};

-    console.touch_values[index] = TransformToTouch(callback);
+    const auto touch_input = TransformToTouch(callback);
+    auto touch_index = GetIndexFromFingerId(index);
+    bool is_new_input = false;
+
+    if (!touch_index.has_value() && touch_input.pressed.value) {
+        touch_index = GetNextFreeIndex();
+        is_new_input = true;
+    }
+
+    // No free entries or invalid state. Ignore input
+    if (!touch_index.has_value()) {
+        return;
+    }
+
+    auto& touch_value = console.touch_values[touch_index.value()];
+
+    if (is_new_input) {
+        touch_value.pressed.value = true;
+        touch_value.id = static_cast<u32>(index);
+    }
+
+    touch_value.x = touch_input.x;
+    touch_value.y = touch_input.y;
+
+    if (!touch_input.pressed.value) {
+        touch_value.pressed.value = false;
+    }

    if (is_configuring) {
        lock.unlock();
@@ -191,11 +215,15 @@ void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, st
        return;
    }

-    // TODO(german77): Remap touch id in sequential order
-    console.touch_state[index] = {
-        .position = {console.touch_values[index].x.value, console.touch_values[index].y.value},
-        .id = static_cast<u32>(console.touch_values[index].id),
-        .pressed = console.touch_values[index].pressed.value,
+    // Touch outside allowed range. Ignore input
+    if (touch_index.value() >= MaxActiveTouchInputs) {
+        return;
+    }
+
+    console.touch_state[touch_index.value()] = {
+        .position = {touch_value.x.value, touch_value.y.value},
+        .id = static_cast<u32>(touch_index.value()),
+        .pressed = touch_input.pressed.value,
    };

    lock.unlock();
@@ -222,6 +250,28 @@ TouchFingerState EmulatedConsole::GetTouch() const {
    return console.touch_state;
 }

+std::optional<std::size_t> EmulatedConsole::GetIndexFromFingerId(std::size_t finger_id) const {
+    for (std::size_t index = 0; index < MaxTouchDevices; ++index) {
+        const auto& finger = console.touch_values[index];
+        if (!finger.pressed.value) {
+            continue;
+        }
+        if (finger.id == static_cast<int>(finger_id)) {
+            return index;
+        }
+    }
+    return std::nullopt;
+}
+
+std::optional<std::size_t> EmulatedConsole::GetNextFreeIndex() const {
+    for (std::size_t index = 0; index < MaxTouchDevices; ++index) {
+        if (!console.touch_values[index].pressed.value) {
+            return index;
+        }
+    }
+    return std::nullopt;
+}
+
 void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {
    std::scoped_lock lock{callback_mutex};
    for (const auto& poller_pair : callback_list) {
@@ -7,6 +7,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <unordered_map>

 #include "common/common_funcs.h"
@@ -20,6 +21,8 @@
 #include "core/hid/motion_input.h"

 namespace Core::HID {
+static constexpr std::size_t MaxTouchDevices = 32;
+static constexpr std::size_t MaxActiveTouchInputs = 16;

 struct ConsoleMotionInfo {
    Common::Input::MotionStatus raw_status{};
@@ -27,13 +30,13 @@ struct ConsoleMotionInfo {
 };

 using ConsoleMotionDevices = std::unique_ptr<Common::Input::InputDevice>;
-using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, 16>;
+using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, MaxTouchDevices>;

 using ConsoleMotionParams = Common::ParamPackage;
-using TouchParams = std::array<Common::ParamPackage, 16>;
+using TouchParams = std::array<Common::ParamPackage, MaxTouchDevices>;

 using ConsoleMotionValues = ConsoleMotionInfo;
-using TouchValues = std::array<Common::Input::TouchStatus, 16>;
+using TouchValues = std::array<Common::Input::TouchStatus, MaxTouchDevices>;

 struct TouchFinger {
    u64 last_touch{};
@@ -55,7 +58,7 @@ struct ConsoleMotion {
    bool is_at_rest{};
 };

-using TouchFingerState = std::array<TouchFinger, 16>;
+using TouchFingerState = std::array<TouchFinger, MaxActiveTouchInputs>;

 struct ConsoleStatus {
    // Data from input_common
@@ -166,6 +169,10 @@ private:
     */
    void SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index);

+    std::optional<std::size_t> GetIndexFromFingerId(std::size_t finger_id) const;
+
+    std::optional<std::size_t> GetNextFreeIndex() const;
+
    /**
     * Triggers a callback that something has changed on the console status
     * @param type Input type of the event to trigger
@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <algorithm>
+
 #include "common/thread.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/input_converter.h"
@@ -144,29 +146,23 @@ void EmulatedController::LoadDevices() {

    LoadTASParams();

-    std::transform(button_params.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
-                   button_params.begin() + Settings::NativeButton::BUTTON_NS_END,
-                   button_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(stick_params.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
-                   stick_params.begin() + Settings::NativeAnalog::STICK_HID_END,
-                   stick_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(motion_params.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
-                   motion_params.begin() + Settings::NativeMotion::MOTION_HID_END,
-                   motion_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(trigger_params.begin(), trigger_params.end(), trigger_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(battery_params.begin(), battery_params.end(), battery_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    camera_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(camera_params);
-    nfc_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(nfc_params);
-    std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::OutputDevice>);
+    std::ranges::transform(button_params, button_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(stick_params, stick_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(motion_params, motion_devices.begin(), Common::Input::CreateInputDevice);
+    std::ranges::transform(trigger_params, trigger_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(battery_params, battery_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    camera_devices = Common::Input::CreateInputDevice(camera_params);
+    nfc_devices = Common::Input::CreateInputDevice(nfc_params);
+    std::ranges::transform(output_params, output_devices.begin(),
+                           Common::Input::CreateOutputDevice);

    // Initialize TAS devices
-    std::transform(tas_button_params.begin(), tas_button_params.end(), tas_button_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
-    std::transform(tas_stick_params.begin(), tas_stick_params.end(), tas_stick_devices.begin(),
-                   Common::Input::CreateDevice<Common::Input::InputDevice>);
+    std::ranges::transform(tas_button_params, tas_button_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(tas_stick_params, tas_stick_devices.begin(),
+                           Common::Input::CreateInputDevice);
 }

 void EmulatedController::LoadTASParams() {
@@ -25,12 +25,12 @@ void EmulatedDevices::ReloadInput() {
        Common::ParamPackage mouse_params;
        mouse_params.Set("engine", "mouse");
        mouse_params.Set("button", static_cast<int>(key_index));
-        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        mouse_device = Common::Input::CreateInputDevice(mouse_params);
        key_index++;
    }

-    mouse_stick_device = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
-        "engine:mouse,axis_x:0,axis_y:1");
+    mouse_stick_device =
+        Common::Input::CreateInputDeviceFromString("engine:mouse,axis_x:0,axis_y:1");

    // First two axis are reserved for mouse position
    key_index = 2;
@@ -38,7 +38,7 @@ void EmulatedDevices::ReloadInput() {
        Common::ParamPackage mouse_params;
        mouse_params.Set("engine", "mouse");
        mouse_params.Set("axis", static_cast<int>(key_index));
-        mouse_device = Common::Input::CreateDevice<Common::Input::InputDevice>(mouse_params);
+        mouse_device = Common::Input::CreateInputDevice(mouse_params);
        key_index++;
    }

@@ -50,7 +50,7 @@ void EmulatedDevices::ReloadInput() {
        keyboard_params.Set("button", static_cast<int>(key_index));
        keyboard_params.Set("port", 1);
        keyboard_params.Set("pad", 0);
-        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        keyboard_device = Common::Input::CreateInputDevice(keyboard_params);
        key_index++;
    }

@@ -62,11 +62,11 @@ void EmulatedDevices::ReloadInput() {
        keyboard_params.Set("button", static_cast<int>(key_index));
        keyboard_params.Set("port", 1);
        keyboard_params.Set("pad", 1);
-        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        keyboard_device = Common::Input::CreateInputDevice(keyboard_params);
        key_index++;
    }

-    ring_analog_device = Common::Input::CreateDevice<Common::Input::InputDevice>(ring_params);
+    ring_analog_device = Common::Input::CreateInputDevice(ring_params);

    for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
        if (!mouse_button_devices[index]) {
@@ -145,6 +145,7 @@ void EmulatedDevices::UnloadInput() {
    for (auto& button : keyboard_modifier_devices) {
        button.reset();
    }
+    ring_analog_device.reset();
 }

 void EmulatedDevices::EnableConfiguration() {
@@ -200,9 +200,6 @@ Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus&
    x = std::clamp(x, 0.0f, 1.0f);
    y = std::clamp(y, 0.0f, 1.0f);

-    // Limit id to maximum number of fingers
-    status.id = std::clamp(status.id, 0, 16);
-
    if (status.pressed.inverted) {
        status.pressed.value = !status.pressed.value;
    }
@@ -149,7 +149,7 @@ public:
            context->AddDomainObject(std::move(iface));
        } else {
            kernel.CurrentProcess()->GetResourceLimit()->Reserve(
-                Kernel::LimitableResource::Sessions, 1);
+                Kernel::LimitableResource::SessionCountMax, 1);

            auto* session = Kernel::KSession::Create(kernel);
            session->Initialize(nullptr, iface->GetServiceName());
@@ -27,16 +27,12 @@ namespace Kernel {

 SessionRequestHandler::SessionRequestHandler(KernelCore& kernel_, const char* service_name_,
                                             ServiceThreadType thread_type)
-    : kernel{kernel_} {
-    if (thread_type == ServiceThreadType::CreateNew) {
-        service_thread = kernel.CreateServiceThread(service_name_);
-    } else {
-        service_thread = kernel.GetDefaultServiceThread();
-    }
-}
+    : kernel{kernel_}, service_thread{thread_type == ServiceThreadType::CreateNew
+                                          ? kernel.CreateServiceThread(service_name_)
+                                          : kernel.GetDefaultServiceThread()} {}

 SessionRequestHandler::~SessionRequestHandler() {
-    kernel.ReleaseServiceThread(service_thread.lock());
+    kernel.ReleaseServiceThread(service_thread);
 }

 void SessionRequestHandler::AcceptSession(KServerPort* server_port) {
@@ -49,7 +45,7 @@ void SessionRequestHandler::AcceptSession(KServerPort* server_port) {
 void SessionRequestHandler::RegisterSession(KServerSession* server_session,
                                            std::shared_ptr<SessionRequestManager> manager) {
    manager->SetSessionHandler(shared_from_this());
-    service_thread.lock()->RegisterServerSession(server_session, manager);
+    service_thread.RegisterServerSession(server_session, manager);
    server_session->Close();
 }

@@ -82,13 +82,13 @@ public:
    void RegisterSession(KServerSession* server_session,
                         std::shared_ptr<SessionRequestManager> manager);

-    std::weak_ptr<ServiceThread> GetServiceThread() const {
+    ServiceThread& GetServiceThread() const {
        return service_thread;
    }

 protected:
    KernelCore& kernel;
-    std::weak_ptr<ServiceThread> service_thread;
+    ServiceThread& service_thread;
 };

 using SessionRequestHandlerWeakPtr = std::weak_ptr<SessionRequestHandler>;
@@ -154,7 +154,7 @@ public:
        session_handler = std::move(handler);
    }

-    std::weak_ptr<ServiceThread> GetServiceThread() const {
+    ServiceThread& GetServiceThread() const {
        return session_handler->GetServiceThread();
    }

@@ -199,7 +199,7 @@ public:
    ~HLERequestContext();

    /// Returns a pointer to the IPC command buffer for this request.
-    u32* CommandBuffer() {
+    [[nodiscard]] u32* CommandBuffer() {
        return cmd_buf.data();
    }

@@ -207,7 +207,7 @@ public:
     * Returns the session through which this request was made. This can be used as a map key to
     * access per-client data on services.
     */
-    Kernel::KServerSession* Session() {
+    [[nodiscard]] Kernel::KServerSession* Session() {
        return server_session;
    }

@@ -217,61 +217,61 @@ public:
    /// Writes data from this context back to the requesting process/thread.
    Result WriteToOutgoingCommandBuffer(KThread& requesting_thread);

-    u32_le GetHipcCommand() const {
+    [[nodiscard]] u32_le GetHipcCommand() const {
        return command;
    }

-    u32_le GetTipcCommand() const {
+    [[nodiscard]] u32_le GetTipcCommand() const {
        return static_cast<u32_le>(command_header->type.Value()) -
               static_cast<u32_le>(IPC::CommandType::TIPC_CommandRegion);
    }

-    u32_le GetCommand() const {
+    [[nodiscard]] u32_le GetCommand() const {
        return command_header->IsTipc() ? GetTipcCommand() : GetHipcCommand();
    }

-    bool IsTipc() const {
+    [[nodiscard]] bool IsTipc() const {
        return command_header->IsTipc();
    }

-    IPC::CommandType GetCommandType() const {
+    [[nodiscard]] IPC::CommandType GetCommandType() const {
        return command_header->type;
    }

-    u64 GetPID() const {
+    [[nodiscard]] u64 GetPID() const {
        return pid;
    }

-    u32 GetDataPayloadOffset() const {
+    [[nodiscard]] u32 GetDataPayloadOffset() const {
        return data_payload_offset;
    }

-    const std::vector<IPC::BufferDescriptorX>& BufferDescriptorX() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorX>& BufferDescriptorX() const {
        return buffer_x_desciptors;
    }

-    const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorA() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorA() const {
        return buffer_a_desciptors;
    }

-    const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorB() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorABW>& BufferDescriptorB() const {
        return buffer_b_desciptors;
    }

-    const std::vector<IPC::BufferDescriptorC>& BufferDescriptorC() const {
+    [[nodiscard]] const std::vector<IPC::BufferDescriptorC>& BufferDescriptorC() const {
        return buffer_c_desciptors;
    }

-    const IPC::DomainMessageHeader& GetDomainMessageHeader() const {
+    [[nodiscard]] const IPC::DomainMessageHeader& GetDomainMessageHeader() const {
        return domain_message_header.value();
    }

-    bool HasDomainMessageHeader() const {
+    [[nodiscard]] bool HasDomainMessageHeader() const {
        return domain_message_header.has_value();
    }

    /// Helper function to read a buffer using the appropriate buffer descriptor
-    std::vector<u8> ReadBuffer(std::size_t buffer_index = 0) const;
+    [[nodiscard]] std::vector<u8> ReadBuffer(std::size_t buffer_index = 0) const;

    /// Helper function to write a buffer using the appropriate buffer descriptor
    std::size_t WriteBuffer(const void* buffer, std::size_t size,
@@ -308,22 +308,34 @@ public:
    }

    /// Helper function to get the size of the input buffer
-    std::size_t GetReadBufferSize(std::size_t buffer_index = 0) const;
+    [[nodiscard]] std::size_t GetReadBufferSize(std::size_t buffer_index = 0) const;

    /// Helper function to get the size of the output buffer
-    std::size_t GetWriteBufferSize(std::size_t buffer_index = 0) const;
+    [[nodiscard]] std::size_t GetWriteBufferSize(std::size_t buffer_index = 0) const;
+
+    /// Helper function to derive the number of elements able to be contained in the read buffer
+    template <typename T>
+    [[nodiscard]] std::size_t GetReadBufferNumElements(std::size_t buffer_index = 0) const {
+        return GetReadBufferSize(buffer_index) / sizeof(T);
+    }
+
+    /// Helper function to derive the number of elements able to be contained in the write buffer
+    template <typename T>
+    [[nodiscard]] std::size_t GetWriteBufferNumElements(std::size_t buffer_index = 0) const {
+        return GetWriteBufferSize(buffer_index) / sizeof(T);
+    }

    /// Helper function to test whether the input buffer at buffer_index can be read
-    bool CanReadBuffer(std::size_t buffer_index = 0) const;
+    [[nodiscard]] bool CanReadBuffer(std::size_t buffer_index = 0) const;

    /// Helper function to test whether the output buffer at buffer_index can be written
-    bool CanWriteBuffer(std::size_t buffer_index = 0) const;
+    [[nodiscard]] bool CanWriteBuffer(std::size_t buffer_index = 0) const;

-    Handle GetCopyHandle(std::size_t index) const {
+    [[nodiscard]] Handle GetCopyHandle(std::size_t index) const {
        return incoming_copy_handles.at(index);
    }

-    Handle GetMoveHandle(std::size_t index) const {
+    [[nodiscard]] Handle GetMoveHandle(std::size_t index) const {
        return incoming_move_handles.at(index);
    }

@@ -348,13 +360,13 @@ public:
        manager = manager_;
    }

-    std::string Description() const;
+    [[nodiscard]] std::string Description() const;

-    KThread& GetThread() {
+    [[nodiscard]] KThread& GetThread() {
        return *thread;
    }

-    std::shared_ptr<SessionRequestManager> GetManager() const {
+    [[nodiscard]] std::shared_ptr<SessionRequestManager> GetManager() const {
        return manager.lock();
    }

@@ -243,6 +243,7 @@ void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout) {
            // If we somehow get an invalid type, abort.
        default:
            ASSERT_MSG(false, "Unknown slab type: {}", slab_types[i]);
+            break;
        }

        // If we've hit the end of a gap, free it.
@@ -265,7 +266,8 @@ void KPageBufferSlabHeap::Initialize(Core::System& system) {
    const size_t slab_size = num_pages * PageSize;

    // Reserve memory from the system resource limit.
-    ASSERT(kernel.GetSystemResourceLimit()->Reserve(LimitableResource::PhysicalMemory, slab_size));
+    ASSERT(
+        kernel.GetSystemResourceLimit()->Reserve(LimitableResource::PhysicalMemoryMax, slab_size));

    // Allocate memory for the slab.
    constexpr auto AllocateOption = KMemoryManager::EncodeOption(
@@ -61,7 +61,7 @@ bool KClientPort::IsSignaled() const {
 Result KClientPort::CreateSession(KClientSession** out) {
    // Reserve a new session from the resource limit.
    KScopedResourceReservation session_reservation(kernel.CurrentProcess()->GetResourceLimit(),
-                                                   LimitableResource::Sessions);
+                                                   LimitableResource::SessionCountMax);
    R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);

    // Update the session counts.
@@ -20,8 +20,12 @@ void KEvent::Initialize(KProcess* owner) {
    m_readable_event.Initialize(this);

    // Set our owner process.
-    m_owner = owner;
-    m_owner->Open();
+    // HACK: this should never be nullptr, but service threads don't have a
+    // proper parent process yet.
+    if (owner != nullptr) {
+        m_owner = owner;
+        m_owner->Open();
+    }

    // Mark initialized.
    m_initialized = true;
@@ -50,8 +54,11 @@ Result KEvent::Clear() {
 void KEvent::PostDestroy(uintptr_t arg) {
    // Release the event count resource the owner process holds.
    KProcess* owner = reinterpret_cast<KProcess*>(arg);
-    owner->GetResourceLimit()->Release(LimitableResource::Events, 1);
-    owner->Close();
+
+    if (owner != nullptr) {
+        owner->GetResourceLimit()->Release(LimitableResource::EventCountMax, 1);
+        owner->Close();
+    }
 }

 } // namespace Kernel
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "core/hle/kernel/k_handle_table.h"
+#include "core/hle/kernel/k_process.h"

 namespace Kernel {

@@ -82,6 +83,22 @@ Result KHandleTable::Add(Handle* out_handle, KAutoObject* obj) {
    R_SUCCEED();
 }

+KScopedAutoObject<KAutoObject> KHandleTable::GetObjectForIpc(Handle handle,
+                                                             KThread* cur_thread) const {
+    // Handle pseudo-handles.
+    ASSERT(cur_thread != nullptr);
+    if (handle == Svc::PseudoHandle::CurrentProcess) {
+        auto* const cur_process = cur_thread->GetOwnerProcess();
+        ASSERT(cur_process != nullptr);
+        return cur_process;
+    }
+    if (handle == Svc::PseudoHandle::CurrentThread) {
+        return cur_thread;
+    }
+
+    return GetObjectForIpcWithoutPseudoHandle(handle);
+}
+
 Result KHandleTable::Reserve(Handle* out_handle) {
    KScopedDisableDispatch dd{m_kernel};
    KScopedSpinLock lk(m_lock);
@@ -113,21 +113,7 @@ public:
        return this->GetObjectImpl(handle);
    }

-    KScopedAutoObject<KAutoObject> GetObjectForIpc(Handle handle, KThread* cur_thread) const {
-        // Handle pseudo-handles.
-        ASSERT(cur_thread != nullptr);
-        if (handle == Svc::PseudoHandle::CurrentProcess) {
-            auto* const cur_process =
-                static_cast<KAutoObject*>(static_cast<void*>(cur_thread->GetOwnerProcess()));
-            ASSERT(cur_process != nullptr);
-            return cur_process;
-        }
-        if (handle == Svc::PseudoHandle::CurrentThread) {
-            return static_cast<KAutoObject*>(cur_thread);
-        }
-
-        return GetObjectForIpcWithoutPseudoHandle(handle);
-    }
+    KScopedAutoObject<KAutoObject> GetObjectForIpc(Handle handle, KThread* cur_thread) const;

    KScopedAutoObject<KAutoObject> GetObjectByIndex(Handle* out_handle, size_t index) const {
        KScopedDisableDispatch dd{m_kernel};
@@ -216,13 +216,15 @@ struct KMemoryInfo {

    constexpr Svc::MemoryInfo GetSvcMemoryInfo() const {
        return {
-            .addr = m_address,
+            .base_address = m_address,
            .size = m_size,
            .state = static_cast<Svc::MemoryState>(m_state & KMemoryState::Mask),
-            .attr = static_cast<Svc::MemoryAttribute>(m_attribute & KMemoryAttribute::UserMask),
-            .perm = static_cast<Svc::MemoryPermission>(m_permission & KMemoryPermission::UserMask),
-            .ipc_refcount = m_ipc_lock_count,
-            .device_refcount = m_device_use_count,
+            .attribute =
+                static_cast<Svc::MemoryAttribute>(m_attribute & KMemoryAttribute::UserMask),
+            .permission =
+                static_cast<Svc::MemoryPermission>(m_permission & KMemoryPermission::UserMask),
+            .ipc_count = m_ipc_lock_count,
+            .device_count = m_device_use_count,
            .padding = {},
        };
    }
@@ -920,8 +920,8 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add

    // Reserve space for any partial pages we allocate.
    const size_t unmapped_size = aligned_src_size - mapping_src_size;
-    KScopedResourceReservation memory_reservation(m_resource_limit,
-                                                  LimitableResource::PhysicalMemory, unmapped_size);
+    KScopedResourceReservation memory_reservation(
+        m_resource_limit, LimitableResource::PhysicalMemoryMax, unmapped_size);
    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

    // Ensure that we manage page references correctly.
@@ -1227,7 +1227,7 @@ Result KPageTable::CleanupForIpcServer(VAddr address, size_t size, KMemoryState
    const VAddr mapping_start = Common::AlignUp((address), PageSize);
    const VAddr mapping_end = Common::AlignDown((address) + size, PageSize);
    const size_t mapping_size = (mapping_start < mapping_end) ? mapping_end - mapping_start : 0;
-    m_resource_limit->Release(LimitableResource::PhysicalMemory, aligned_size - mapping_size);
+    m_resource_limit->Release(LimitableResource::PhysicalMemoryMax, aligned_size - mapping_size);

    R_SUCCEED();
 }
@@ -1568,7 +1568,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
        {
            // Reserve the memory from the process resource limit.
            KScopedResourceReservation memory_reservation(
-                m_resource_limit, LimitableResource::PhysicalMemory, size - mapped_size);
+                m_resource_limit, LimitableResource::PhysicalMemoryMax, size - mapped_size);
            R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

            // Allocate pages for the new memory.
@@ -1908,7 +1908,7 @@ Result KPageTable::UnmapPhysicalMemory(VAddr address, size_t size) {

    // Release the memory resource.
    m_mapped_physical_memory_size -= mapped_size;
-    m_resource_limit->Release(LimitableResource::PhysicalMemory, mapped_size);
+    m_resource_limit->Release(LimitableResource::PhysicalMemoryMax, mapped_size);

    // Update memory blocks.
    m_memory_block_manager.Update(std::addressof(allocator), address, size / PageSize,
@@ -2301,6 +2301,7 @@ Result KPageTable::SetProcessMemoryPermission(VAddr addr, size_t size,
            break;
        default:
            ASSERT(false);
+            break;
        }
    }

@@ -2492,7 +2493,7 @@ Result KPageTable::SetHeapSize(VAddr* out, size_t size) {
                          OperationType::Unmap));

            // Release the memory from the resource limit.
-            m_resource_limit->Release(LimitableResource::PhysicalMemory, num_pages * PageSize);
+            m_resource_limit->Release(LimitableResource::PhysicalMemoryMax, num_pages * PageSize);

            // Apply the memory block update.
            m_memory_block_manager.Update(std::addressof(allocator), m_heap_region_start + size,
@@ -2522,7 +2523,7 @@ Result KPageTable::SetHeapSize(VAddr* out, size_t size) {

    // Reserve memory for the heap extension.
    KScopedResourceReservation memory_reservation(
-        m_resource_limit, LimitableResource::PhysicalMemory, allocation_size);
+        m_resource_limit, LimitableResource::PhysicalMemoryMax, allocation_size);
    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

    // Allocate pages for the heap extension.
@@ -2803,6 +2804,7 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, const KPageGroup& page_
            break;
        default:
            ASSERT(false);
+            break;
        }

        addr += size;
@@ -2838,6 +2840,7 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, KMemoryPermission perm,
        break;
    default:
        ASSERT(false);
+        break;
    }
    R_SUCCEED();
 }
@@ -320,6 +320,9 @@ public:
    constexpr VAddr GetAliasCodeRegionStart() const {
        return m_alias_code_region_start;
    }
+    constexpr VAddr GetAliasCodeRegionEnd() const {
+        return m_alias_code_region_end;
+    }
    constexpr VAddr GetAliasCodeRegionSize() const {
        return m_alias_code_region_end - m_alias_code_region_start;
    }
@@ -38,7 +38,7 @@ namespace {
 */
 void SetupMainThread(Core::System& system, KProcess& owner_process, u32 priority, VAddr stack_top) {
    const VAddr entry_point = owner_process.PageTable().GetCodeRegionStart();
-    ASSERT(owner_process.GetResourceLimit()->Reserve(LimitableResource::Threads, 1));
+    ASSERT(owner_process.GetResourceLimit()->Reserve(LimitableResource::ThreadCountMax, 1));

    KThread* thread = KThread::Create(system.Kernel());
    SCOPE_EXIT({ thread->Close(); });
@@ -124,7 +124,7 @@ void KProcess::DecrementRunningThreadCount() {
 }

 u64 KProcess::GetTotalPhysicalMemoryAvailable() {
-    const u64 capacity{resource_limit->GetFreeValue(LimitableResource::PhysicalMemory) +
+    const u64 capacity{resource_limit->GetFreeValue(LimitableResource::PhysicalMemoryMax) +
                       page_table.GetNormalMemorySize() + GetSystemResourceSize() + image_size +
                       main_thread_stack_size};
    if (const auto pool_size = kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application);
@@ -349,8 +349,8 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
    // We currently do not support process-specific system resource
    UNIMPLEMENTED_IF(system_resource_size != 0);

-    KScopedResourceReservation memory_reservation(resource_limit, LimitableResource::PhysicalMemory,
-                                                  code_size + system_resource_size);
+    KScopedResourceReservation memory_reservation(
+        resource_limit, LimitableResource::PhysicalMemoryMax, code_size + system_resource_size);
    if (!memory_reservation.Succeeded()) {
        LOG_ERROR(Kernel, "Could not reserve process memory requirements of size {:X} bytes",
                  code_size + system_resource_size);
@@ -395,6 +395,7 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:

    default:
        ASSERT(false);
+        break;
    }

    // Create TLS region
@@ -406,8 +407,8 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:

 void KProcess::Run(s32 main_thread_priority, u64 stack_size) {
    AllocateMainThreadStack(stack_size);
-    resource_limit->Reserve(LimitableResource::Threads, 1);
-    resource_limit->Reserve(LimitableResource::PhysicalMemory, main_thread_stack_size);
+    resource_limit->Reserve(LimitableResource::ThreadCountMax, 1);
+    resource_limit->Reserve(LimitableResource::PhysicalMemoryMax, main_thread_stack_size);

    const std::size_t heap_capacity{memory_usage_capacity - (main_thread_stack_size + image_size)};
    ASSERT(!page_table.SetMaxHeapSize(heap_capacity).IsError());
@@ -442,7 +443,7 @@ void KProcess::PrepareForTermination() {
    plr_address = 0;

    if (resource_limit) {
-        resource_limit->Release(LimitableResource::PhysicalMemory,
+        resource_limit->Release(LimitableResource::PhysicalMemoryMax,
                                main_thread_stack_size + image_size);
    }

@@ -159,12 +159,13 @@ KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical
    // TODO(bunnei): These values are the system defaults, the limits for service processes are
    // lower. These should use the correct limit values.

-    ASSERT(resource_limit->SetLimitValue(LimitableResource::PhysicalMemory, physical_memory_size)
+    ASSERT(resource_limit->SetLimitValue(LimitableResource::PhysicalMemoryMax, physical_memory_size)
               .IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Threads, 800).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Events, 900).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::TransferMemory, 200).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Sessions, 1133).IsSuccess());
+    ASSERT(resource_limit->SetLimitValue(LimitableResource::ThreadCountMax, 800).IsSuccess());
+    ASSERT(resource_limit->SetLimitValue(LimitableResource::EventCountMax, 900).IsSuccess());
+    ASSERT(
+        resource_limit->SetLimitValue(LimitableResource::TransferMemoryCountMax, 200).IsSuccess());
+    ASSERT(resource_limit->SetLimitValue(LimitableResource::SessionCountMax, 1133).IsSuccess());

    return resource_limit;
 }
@@ -16,15 +16,8 @@ class CoreTiming;

 namespace Kernel {
 class KernelCore;
-enum class LimitableResource : u32 {
-    PhysicalMemory = 0,
-    Threads = 1,
-    Events = 2,
-    TransferMemory = 3,
-    Sessions = 4,

-    Count,
-};
+using LimitableResource = Svc::LimitableResource;

 constexpr bool IsValidResourceType(LimitableResource type) {
    return type < LimitableResource::Count;
@@ -384,7 +384,8 @@ void KScheduler::SwitchThread(KThread* next_thread) {

 void KScheduler::ScheduleImpl() {
    // First, clear the needs scheduling bool.
-    m_state.needs_scheduling.store(false, std::memory_order_seq_cst);
+    m_state.needs_scheduling.store(false, std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_seq_cst);

    // Load the appropriate thread pointers for scheduling.
    KThread* const cur_thread{GetCurrentThreadPointer(kernel)};
@@ -400,7 +401,8 @@ void KScheduler::ScheduleImpl() {
    // If there aren't, we want to check if the highest priority thread is the same as the current
    // thread.
    if (highest_priority_thread == cur_thread) {
-        // If they're the same, then we can just return.
+        // If they're the same, then we can just issue a memory barrier and return.
+        std::atomic_thread_fence(std::memory_order_seq_cst);
        return;
    }

@@ -476,7 +478,8 @@ void KScheduler::ScheduleImplFiber() {

        // We failed to successfully do the context switch, and need to retry.
        // Clear needs_scheduling.
-        m_state.needs_scheduling.store(false, std::memory_order_seq_cst);
+        m_state.needs_scheduling.store(false, std::memory_order_relaxed);
+        std::atomic_thread_fence(std::memory_order_seq_cst);

        // Refresh the highest priority thread.
        highest_priority_thread = m_state.highest_priority_thread;
@@ -60,6 +60,9 @@ public:

        // Release an instance of the lock.
        if ((--lock_count) == 0) {
+            // Perform a memory barrier here.
+            std::atomic_thread_fence(std::memory_order_seq_cst);
+
            // We're no longer going to hold the lock. Take note of what cores need scheduling.
            const u64 cores_needing_scheduling =
                SchedulerType::UpdateHighestPriorityThreads(kernel);
@@ -76,7 +76,7 @@ void KSession::OnClientClosed() {
 void KSession::PostDestroy(uintptr_t arg) {
    // Release the session count resource the owner process holds.
    KProcess* owner = reinterpret_cast<KProcess*>(arg);
-    owner->GetResourceLimit()->Release(LimitableResource::Sessions, 1);
+    owner->GetResourceLimit()->Release(LimitableResource::SessionCountMax, 1);
    owner->Close();
 }

@@ -14,7 +14,7 @@ namespace Kernel {
 KSharedMemory::KSharedMemory(KernelCore& kernel_) : KAutoObjectWithSlabHeapAndContainer{kernel_} {}

 KSharedMemory::~KSharedMemory() {
-    kernel.GetSystemResourceLimit()->Release(LimitableResource::PhysicalMemory, size);
+    kernel.GetSystemResourceLimit()->Release(LimitableResource::PhysicalMemoryMax, size);
 }

 Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
@@ -35,7 +35,7 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
    KResourceLimit* reslimit = kernel.GetSystemResourceLimit();

    // Reserve memory for ourselves.
-    KScopedResourceReservation memory_reservation(reslimit, LimitableResource::PhysicalMemory,
+    KScopedResourceReservation memory_reservation(reslimit, LimitableResource::PhysicalMemoryMax,
                                                  size_);
    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

@@ -57,7 +57,7 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o

 void KSharedMemory::Finalize() {
    // Release the memory reservation.
-    resource_limit->Release(LimitableResource::PhysicalMemory, size);
+    resource_limit->Release(LimitableResource::PhysicalMemoryMax, size);
    resource_limit->Close();

    // Perform inherited finalization.
@@ -263,9 +263,9 @@ Result KThread::InitializeThread(KThread* thread, KThreadFunction func, uintptr_
    R_SUCCEED();
 }

-Result KThread::InitializeDummyThread(KThread* thread) {
+Result KThread::InitializeDummyThread(KThread* thread, KProcess* owner) {
    // Initialize the thread.
-    R_TRY(thread->Initialize({}, {}, {}, DummyThreadPriority, 3, {}, ThreadType::Dummy));
+    R_TRY(thread->Initialize({}, {}, {}, DummyThreadPriority, 3, owner, ThreadType::Dummy));

    // Initialize emulation parameters.
    thread->stack_parameters.disable_count = 0;
@@ -303,7 +303,7 @@ void KThread::PostDestroy(uintptr_t arg) {
    const bool resource_limit_release_hint = (arg & 1);
    const s64 hint_value = (resource_limit_release_hint ? 0 : 1);
    if (owner != nullptr) {
-        owner->GetResourceLimit()->Release(LimitableResource::Threads, 1, hint_value);
+        owner->GetResourceLimit()->Release(LimitableResource::ThreadCountMax, 1, hint_value);
        owner->Close();
    }
 }
@@ -1054,7 +1054,7 @@ void KThread::Exit() {

    // Release the thread resource hint, running thread count from parent.
    if (parent != nullptr) {
-        parent->GetResourceLimit()->Release(Kernel::LimitableResource::Threads, 0, 1);
+        parent->GetResourceLimit()->Release(Kernel::LimitableResource::ThreadCountMax, 0, 1);
        resource_limit_release_hint = true;
        parent->DecrementRunningThreadCount();
    }
@@ -415,7 +415,7 @@ public:

    static void PostDestroy(uintptr_t arg);

-    [[nodiscard]] static Result InitializeDummyThread(KThread* thread);
+    [[nodiscard]] static Result InitializeDummyThread(KThread* thread, KProcess* owner);

    [[nodiscard]] static Result InitializeMainThread(Core::System& system, KThread* thread,
                                                     s32 virt_core);
@@ -37,7 +37,7 @@ void KTransferMemory::Finalize() {

 void KTransferMemory::PostDestroy(uintptr_t arg) {
    KProcess* owner = reinterpret_cast<KProcess*>(arg);
-    owner->GetResourceLimit()->Release(LimitableResource::TransferMemory, 1);
+    owner->GetResourceLimit()->Release(LimitableResource::TransferMemoryCountMax, 1);
    owner->Close();
 }

@@ -91,9 +91,9 @@ struct KernelCore::Impl {
                                       pt_heap_region.GetSize());
        }

-        RegisterHostThread();
+        RegisterHostThread(nullptr);

-        default_service_thread = CreateServiceThread(kernel, "DefaultServiceThread");
+        default_service_thread = &CreateServiceThread(kernel, "DefaultServiceThread");
    }

    void InitializeCores() {
@@ -229,18 +229,22 @@ struct KernelCore::Impl {
        const auto kernel_size{sizes.second};

        // If setting the default system values fails, then something seriously wrong has occurred.
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::PhysicalMemory, total_size)
+        ASSERT(
+            system_resource_limit->SetLimitValue(LimitableResource::PhysicalMemoryMax, total_size)
+                .IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::ThreadCountMax, 800)
                   .IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::Threads, 800).IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::Events, 900).IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::TransferMemory, 200)
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::EventCountMax, 900)
                   .IsSuccess());
-        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::Sessions, 1133).IsSuccess());
-        system_resource_limit->Reserve(LimitableResource::PhysicalMemory, kernel_size);
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::TransferMemoryCountMax, 200)
+                   .IsSuccess());
+        ASSERT(system_resource_limit->SetLimitValue(LimitableResource::SessionCountMax, 1133)
+                   .IsSuccess());
+        system_resource_limit->Reserve(LimitableResource::PhysicalMemoryMax, kernel_size);

        // Reserve secure applet memory, introduced in firmware 5.0.0
        constexpr u64 secure_applet_memory_size{4_MiB};
-        ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemory,
+        ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemoryMax,
                                              secure_applet_memory_size));
    }

@@ -373,15 +377,18 @@ struct KernelCore::Impl {
    }

    // Gets the dummy KThread for the caller, allocating a new one if this is the first time
-    KThread* GetHostDummyThread() {
+    KThread* GetHostDummyThread(KThread* existing_thread) {
        auto initialize = [this](KThread* thread) {
-            ASSERT(KThread::InitializeDummyThread(thread).IsSuccess());
+            ASSERT(KThread::InitializeDummyThread(thread, nullptr).IsSuccess());
            thread->SetName(fmt::format("DummyThread:{}", GetHostThreadId()));
            return thread;
        };

-        thread_local auto raw_thread = KThread(system.Kernel());
-        thread_local auto thread = initialize(&raw_thread);
+        thread_local KThread raw_thread{system.Kernel()};
+        thread_local KThread* thread = nullptr;
+        if (thread == nullptr) {
+            thread = (existing_thread == nullptr) ? initialize(&raw_thread) : existing_thread;
+        }

        return thread;
    }
@@ -396,9 +403,9 @@ struct KernelCore::Impl {
    }

    /// Registers a new host thread by allocating a host thread ID for it
-    void RegisterHostThread() {
+    void RegisterHostThread(KThread* existing_thread) {
        [[maybe_unused]] const auto this_id = GetHostThreadId();
-        [[maybe_unused]] const auto dummy_thread = GetHostDummyThread();
+        [[maybe_unused]] const auto dummy_thread = GetHostDummyThread(existing_thread);
    }

    [[nodiscard]] u32 GetCurrentHostThreadID() {
@@ -429,7 +436,7 @@ struct KernelCore::Impl {
    KThread* GetCurrentEmuThread() {
        const auto thread_id = GetCurrentHostThreadID();
        if (thread_id >= Core::Hardware::NUM_CPU_CORES) {
-            return GetHostDummyThread();
+            return GetHostDummyThread(nullptr);
        }

        return current_thread;
@@ -779,33 +786,31 @@ struct KernelCore::Impl {
        search->second(system.ServiceManager(), server_port);
    }

-    std::weak_ptr<Kernel::ServiceThread> CreateServiceThread(KernelCore& kernel,
-                                                             const std::string& name) {
-        auto service_thread = std::make_shared<Kernel::ServiceThread>(kernel, name);
+    Kernel::ServiceThread& CreateServiceThread(KernelCore& kernel, const std::string& name) {
+        auto* ptr = new ServiceThread(kernel, name);

        service_threads_manager.QueueWork(
-            [this, service_thread]() { service_threads.emplace(service_thread); });
+            [this, ptr]() { service_threads.emplace(ptr, std::unique_ptr<ServiceThread>(ptr)); });

-        return service_thread;
+        return *ptr;
    }

-    void ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread) {
-        if (auto strong_ptr = service_thread.lock()) {
-            if (strong_ptr == default_service_thread.lock()) {
-                // Nothing to do here, the service is using default_service_thread, which will be
-                // released on shutdown.
-                return;
-            }
+    void ReleaseServiceThread(Kernel::ServiceThread& service_thread) {
+        auto* ptr = &service_thread;

-            service_threads_manager.QueueWork(
-                [this, strong_ptr{std::move(strong_ptr)}]() { service_threads.erase(strong_ptr); });
+        if (ptr == default_service_thread) {
+            // Nothing to do here, the service is using default_service_thread, which will be
+            // released on shutdown.
+            return;
        }
+
+        service_threads_manager.QueueWork([this, ptr]() { service_threads.erase(ptr); });
    }

    void ClearServiceThreads() {
        service_threads_manager.QueueWork([this] {
            service_threads.clear();
-            default_service_thread.reset();
+            default_service_thread = nullptr;
            service_thread_barrier.Sync();
        });
        service_thread_barrier.Sync();
@@ -881,8 +886,8 @@ struct KernelCore::Impl {
    std::unique_ptr<KMemoryLayout> memory_layout;

    // Threads used for services
-    std::unordered_set<std::shared_ptr<ServiceThread>> service_threads;
-    std::weak_ptr<ServiceThread> default_service_thread;
+    std::unordered_map<ServiceThread*, std::unique_ptr<ServiceThread>> service_threads;
+    ServiceThread* default_service_thread{};
    Common::ThreadWorker service_threads_manager;
    Common::Barrier service_thread_barrier;

@@ -1122,8 +1127,12 @@ void KernelCore::RegisterCoreThread(std::size_t core_id) {
    impl->RegisterCoreThread(core_id);
 }

-void KernelCore::RegisterHostThread() {
-    impl->RegisterHostThread();
+void KernelCore::RegisterHostThread(KThread* existing_thread) {
+    impl->RegisterHostThread(existing_thread);
+
+    if (existing_thread != nullptr) {
+        ASSERT(GetCurrentEmuThread() == existing_thread);
+    }
 }

 u32 KernelCore::GetCurrentHostThreadID() const {
@@ -1198,16 +1207,28 @@ void KernelCore::Suspend(bool suspended) {
    const bool should_suspend{exception_exited || suspended};
    const auto activity = should_suspend ? ProcessActivity::Paused : ProcessActivity::Runnable;

-    for (auto* process : GetProcessList()) {
-        process->SetActivity(activity);
+    std::vector<KScopedAutoObject<KThread>> process_threads;
+    {
+        KScopedSchedulerLock sl{*this};
+
+        if (auto* process = CurrentProcess(); process != nullptr) {
+            process->SetActivity(activity);
+
+            if (!should_suspend) {
+                // Runnable now; no need to wait.
+                return;
+            }

-        if (should_suspend) {
-            // Wait for execution to stop
            for (auto* thread : process->GetThreadList()) {
-                thread->WaitUntilSuspended();
+                process_threads.emplace_back(thread);
            }
        }
    }
+
+    // Wait for execution to stop.
+    for (auto& thread : process_threads) {
+        thread->WaitUntilSuspended();
+    }
 }

 void KernelCore::ShutdownCores() {
@@ -1239,15 +1260,15 @@ void KernelCore::ExitSVCProfile() {
    MicroProfileLeave(MICROPROFILE_TOKEN(Kernel_SVC), impl->svc_ticks[CurrentPhysicalCoreIndex()]);
 }

-std::weak_ptr<Kernel::ServiceThread> KernelCore::CreateServiceThread(const std::string& name) {
+Kernel::ServiceThread& KernelCore::CreateServiceThread(const std::string& name) {
    return impl->CreateServiceThread(*this, name);
 }

-std::weak_ptr<Kernel::ServiceThread> KernelCore::GetDefaultServiceThread() const {
-    return impl->default_service_thread;
+Kernel::ServiceThread& KernelCore::GetDefaultServiceThread() const {
+    return *impl->default_service_thread;
 }

-void KernelCore::ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread) {
+void KernelCore::ReleaseServiceThread(Kernel::ServiceThread& service_thread) {
    impl->ReleaseServiceThread(service_thread);
 }

@@ -240,7 +240,7 @@ public:
    void RegisterCoreThread(std::size_t core_id);

    /// Register the current thread as a non CPU core thread.
-    void RegisterHostThread();
+    void RegisterHostThread(KThread* existing_thread = nullptr);

    /// Gets the virtual memory manager for the kernel.
    KMemoryManager& MemoryManager();
@@ -309,24 +309,24 @@ public:
     * See GetDefaultServiceThread.
     * @param name String name for the ServerSession creating this thread, used for debug
     * purposes.
-     * @returns The a weak pointer newly created service thread.
+     * @returns A reference to the newly created service thread.
     */
-    std::weak_ptr<Kernel::ServiceThread> CreateServiceThread(const std::string& name);
+    Kernel::ServiceThread& CreateServiceThread(const std::string& name);

    /**
     * Gets the default host service thread, which executes HLE service requests. Unless service
     * requests need to block on the host, the default service thread should be used in favor of
     * creating a new service thread.
-     * @returns The a weak pointer for the default service thread.
+     * @returns A reference to the default service thread.
     */
-    std::weak_ptr<Kernel::ServiceThread> GetDefaultServiceThread() const;
+    Kernel::ServiceThread& GetDefaultServiceThread() const;

    /**
     * Releases a HLE service thread, instructing KernelCore to free it. This should be called when
     * the ServerSession associated with the thread is destroyed.
     * @param service_thread Service thread to release.
     */
-    void ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread);
+    void ReleaseServiceThread(Kernel::ServiceThread& service_thread);

    /// Workaround for single-core mode when preempting threads while idle.
    bool IsPhantomModeForSingleCore() const;
@@ -12,7 +12,7 @@ namespace Kernel {

 PhysicalCore::PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_)
    : core_index{core_index_}, system{system_}, scheduler{scheduler_} {
-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
    // TODO(bunnei): Initialization relies on a core being available. We may later replace this with
    // a 32-bit instance of Dynarmic. This should be abstracted out to a CPU manager.
    auto& kernel = system.Kernel();
@@ -26,7 +26,7 @@ PhysicalCore::PhysicalCore(std::size_t core_index_, Core::System& system_, KSche
 PhysicalCore::~PhysicalCore() = default;

 void PhysicalCore::Initialize([[maybe_unused]] bool is_64_bit) {
-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
    auto& kernel = system.Kernel();
    if (!is_64_bit) {
        // We already initialized a 64-bit core, replace with a 32-bit one.
@@ -36,11 +36,11 @@ public:
 private:
    KernelCore& kernel;

-    std::jthread m_thread;
+    std::jthread m_host_thread;
    std::mutex m_session_mutex;
    std::map<KServerSession*, std::shared_ptr<SessionRequestManager>> m_sessions;
    KEvent* m_wakeup_event;
-    KProcess* m_process;
+    KThread* m_thread;
    std::atomic<bool> m_shutdown_requested;
    const std::string m_service_name;
 };
@@ -132,7 +132,7 @@ void ServiceThread::Impl::SessionClosed(KServerSession* server_session,
 void ServiceThread::Impl::LoopProcess() {
    Common::SetCurrentThreadName(m_service_name.c_str());

-    kernel.RegisterHostThread();
+    kernel.RegisterHostThread(m_thread);

    while (!m_shutdown_requested.load()) {
        WaitAndProcessImpl();
@@ -160,7 +160,7 @@ ServiceThread::Impl::~Impl() {
    // Shut down the processing thread.
    m_shutdown_requested.store(true);
    m_wakeup_event->Signal();
-    m_thread.join();
+    m_host_thread.join();

    // Lock mutex.
    m_session_mutex.lock();
@@ -177,33 +177,22 @@ ServiceThread::Impl::~Impl() {
    m_wakeup_event->GetReadableEvent().Close();
    m_wakeup_event->Close();

-    // Close process.
-    m_process->Close();
+    // Close thread.
+    m_thread->Close();
 }

 ServiceThread::Impl::Impl(KernelCore& kernel_, const std::string& service_name)
    : kernel{kernel_}, m_service_name{service_name} {
-    // Initialize process.
-    m_process = KProcess::Create(kernel);
-    KProcess::Initialize(m_process, kernel.System(), service_name,
-                         KProcess::ProcessType::KernelInternal, kernel.GetSystemResourceLimit());
-
-    // Reserve a new event from the process resource limit
-    KScopedResourceReservation event_reservation(m_process, LimitableResource::Events);
-    ASSERT(event_reservation.Succeeded());
-
    // Initialize event.
    m_wakeup_event = KEvent::Create(kernel);
-    m_wakeup_event->Initialize(m_process);
+    m_wakeup_event->Initialize(nullptr);

-    // Commit the event reservation.
-    event_reservation.Commit();
-
-    // Register the event.
-    KEvent::Register(kernel, m_wakeup_event);
+    // Initialize thread.
+    m_thread = KThread::Create(kernel);
+    ASSERT(KThread::InitializeDummyThread(m_thread, nullptr).IsSuccess());

    // Start thread.
-    m_thread = std::jthread([this] { LoopProcess(); });
+    m_host_thread = std::jthread([this] { LoopProcess(); });
 }

 ServiceThread::ServiceThread(KernelCore& kernel, const std::string& name)
@@ -267,7 +267,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien

    // Reserve a new session from the process resource limit.
    // FIXME: LimitableResource_SessionCountMax
-    KScopedResourceReservation session_reservation(&process, LimitableResource::Sessions);
+    KScopedResourceReservation session_reservation(&process, LimitableResource::SessionCountMax);
    if (session_reservation.Succeeded()) {
        session = T::Create(system.Kernel());
    } else {
@@ -298,7 +298,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien

        // We successfully allocated a session, so add the object we allocated to the resource
        // limit.
-        // system.Kernel().GetSystemResourceLimit().Reserve(LimitableResource::Sessions, 1);
+        // system.Kernel().GetSystemResourceLimit().Reserve(LimitableResource::SessionCountMax, 1);
    }

    // Check that we successfully created a session.
@@ -656,27 +656,12 @@ static Result ArbitrateUnlock32(Core::System& system, u32 address) {
    return ArbitrateUnlock(system, address);
 }

-enum class BreakType : u32 {
-    Panic = 0,
-    AssertionFailed = 1,
-    PreNROLoad = 3,
-    PostNROLoad = 4,
-    PreNROUnload = 5,
-    PostNROUnload = 6,
-    CppException = 7,
-};
-
-struct BreakReason {
-    union {
-        u32 raw;
-        BitField<0, 30, BreakType> break_type;
-        BitField<31, 1, u32> signal_debugger;
-    };
-};
-
 /// Break program execution
 static void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
-    BreakReason break_reason{reason};
+    BreakReason break_reason =
+        static_cast<BreakReason>(reason & ~static_cast<u32>(BreakReason::NotificationOnlyFlag));
+    bool notification_only = (reason & static_cast<u32>(BreakReason::NotificationOnlyFlag)) != 0;
+
    bool has_dumped_buffer{};
    std::vector<u8> debug_buffer;

@@ -705,57 +690,56 @@ static void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
        }
        has_dumped_buffer = true;
    };
-    switch (break_reason.break_type) {
-    case BreakType::Panic:
-        LOG_CRITICAL(Debug_Emulated, "Signalling debugger, PANIC! info1=0x{:016X}, info2=0x{:016X}",
+    switch (break_reason) {
+    case BreakReason::Panic:
+        LOG_CRITICAL(Debug_Emulated, "Userspace PANIC! info1=0x{:016X}, info2=0x{:016X}", info1,
+                     info2);
+        handle_debug_buffer(info1, info2);
+        break;
+    case BreakReason::Assert:
+        LOG_CRITICAL(Debug_Emulated, "Userspace Assertion failed! info1=0x{:016X}, info2=0x{:016X}",
                     info1, info2);
        handle_debug_buffer(info1, info2);
        break;
-    case BreakType::AssertionFailed:
-        LOG_CRITICAL(Debug_Emulated,
-                     "Signalling debugger, Assertion failed! info1=0x{:016X}, info2=0x{:016X}",
-                     info1, info2);
+    case BreakReason::User:
+        LOG_WARNING(Debug_Emulated, "Userspace Break! 0x{:016X} with size 0x{:016X}", info1, info2);
        handle_debug_buffer(info1, info2);
        break;
-    case BreakType::PreNROLoad:
-        LOG_WARNING(
-            Debug_Emulated,
-            "Signalling debugger, Attempting to load an NRO at 0x{:016X} with size 0x{:016X}",
-            info1, info2);
+    case BreakReason::PreLoadDll:
+        LOG_INFO(Debug_Emulated,
+                 "Userspace Attempting to load an NRO at 0x{:016X} with size 0x{:016X}", info1,
+                 info2);
        break;
-    case BreakType::PostNROLoad:
-        LOG_WARNING(Debug_Emulated,
-                    "Signalling debugger, Loaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
-                    info2);
+    case BreakReason::PostLoadDll:
+        LOG_INFO(Debug_Emulated, "Userspace Loaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
+                 info2);
        break;
-    case BreakType::PreNROUnload:
-        LOG_WARNING(
-            Debug_Emulated,
-            "Signalling debugger, Attempting to unload an NRO at 0x{:016X} with size 0x{:016X}",
-            info1, info2);
+    case BreakReason::PreUnloadDll:
+        LOG_INFO(Debug_Emulated,
+                 "Userspace Attempting to unload an NRO at 0x{:016X} with size 0x{:016X}", info1,
+                 info2);
        break;
-    case BreakType::PostNROUnload:
-        LOG_WARNING(Debug_Emulated,
-                    "Signalling debugger, Unloaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
-                    info2);
+    case BreakReason::PostUnloadDll:
+        LOG_INFO(Debug_Emulated, "Userspace Unloaded an NRO at 0x{:016X} with size 0x{:016X}",
+                 info1, info2);
        break;
-    case BreakType::CppException:
+    case BreakReason::CppException:
        LOG_CRITICAL(Debug_Emulated, "Signalling debugger. Uncaught C++ exception encountered.");
        break;
    default:
        LOG_WARNING(
            Debug_Emulated,
-            "Signalling debugger, Unknown break reason {}, info1=0x{:016X}, info2=0x{:016X}",
-            static_cast<u32>(break_reason.break_type.Value()), info1, info2);
+            "Signalling debugger, Unknown break reason {:#X}, info1=0x{:016X}, info2=0x{:016X}",
+            reason, info1, info2);
        handle_debug_buffer(info1, info2);
        break;
    }

-    system.GetReporter().SaveSvcBreakReport(
-        static_cast<u32>(break_reason.break_type.Value()), break_reason.signal_debugger.As<bool>(),
-        info1, info2, has_dumped_buffer ? std::make_optional(debug_buffer) : std::nullopt);
+    system.GetReporter().SaveSvcBreakReport(reason, notification_only, info1, info2,
+                                            has_dumped_buffer ? std::make_optional(debug_buffer)
+                                                              : std::nullopt);

-    if (!break_reason.signal_debugger) {
+    if (!notification_only) {
        LOG_CRITICAL(
            Debug_Emulated,
            "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
@@ -1716,13 +1700,13 @@ static Result QueryProcessMemory(Core::System& system, VAddr memory_info_address
    auto& memory{system.Memory()};
    const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};

-    memory.Write64(memory_info_address + 0x00, memory_info.addr);
+    memory.Write64(memory_info_address + 0x00, memory_info.base_address);
    memory.Write64(memory_info_address + 0x08, memory_info.size);
    memory.Write32(memory_info_address + 0x10, static_cast<u32>(memory_info.state) & 0xff);
-    memory.Write32(memory_info_address + 0x14, static_cast<u32>(memory_info.attr));
-    memory.Write32(memory_info_address + 0x18, static_cast<u32>(memory_info.perm));
-    memory.Write32(memory_info_address + 0x1c, memory_info.ipc_refcount);
-    memory.Write32(memory_info_address + 0x20, memory_info.device_refcount);
+    memory.Write32(memory_info_address + 0x14, static_cast<u32>(memory_info.attribute));
+    memory.Write32(memory_info_address + 0x18, static_cast<u32>(memory_info.permission));
+    memory.Write32(memory_info_address + 0x1c, memory_info.ipc_count);
+    memory.Write32(memory_info_address + 0x20, memory_info.device_count);
    memory.Write32(memory_info_address + 0x24, 0);

    // Page info appears to be currently unused by the kernel and is always set to zero.
@@ -1943,7 +1927,7 @@ static Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry

    // Reserve a new thread from the process resource limit (waiting up to 100ms).
    KScopedResourceReservation thread_reservation(
-        kernel.CurrentProcess(), LimitableResource::Threads, 1,
+        kernel.CurrentProcess(), LimitableResource::ThreadCountMax, 1,
        system.CoreTiming().GetGlobalTimeNs().count() + 100000000);
    if (!thread_reservation.Succeeded()) {
        LOG_ERROR(Kernel_SVC, "Could not reserve a new thread");
@@ -2344,7 +2328,7 @@ static Result CreateTransferMemory(Core::System& system, Handle* out, VAddr addr

    // Reserve a new transfer memory from the process resource limit.
    KScopedResourceReservation trmem_reservation(kernel.CurrentProcess(),
-                                                 LimitableResource::TransferMemory);
+                                                 LimitableResource::TransferMemoryCountMax);
    R_UNLESS(trmem_reservation.Succeeded(), ResultLimitReached);

    // Create the transfer memory.
@@ -2496,7 +2480,7 @@ static Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_r

    // Reserve a new event from the process resource limit
    KScopedResourceReservation event_reservation(kernel.CurrentProcess(),
-                                                 LimitableResource::Events);
+                                                 LimitableResource::EventCountMax);
    R_UNLESS(event_reservation.Succeeded(), ResultLimitReached);

    // Create a new event.
@@ -2539,11 +2523,6 @@ static Result CreateEvent32(Core::System& system, Handle* out_write, Handle* out
 static Result GetProcessInfo(Core::System& system, u64* out, Handle process_handle, u32 type) {
    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, type=0x{:X}", process_handle, type);

-    // This function currently only allows retrieving a process' status.
-    enum class InfoType {
-        Status,
-    };
-
    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
    KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
    if (process.IsNull()) {
@@ -2552,9 +2531,9 @@ static Result GetProcessInfo(Core::System& system, u64* out, Handle process_hand
        return ResultInvalidHandle;
    }

-    const auto info_type = static_cast<InfoType>(type);
-    if (info_type != InfoType::Status) {
-        LOG_ERROR(Kernel_SVC, "Expected info_type to be Status but got {} instead", type);
+    const auto info_type = static_cast<ProcessInfoType>(type);
+    if (info_type != ProcessInfoType::ProcessState) {
+        LOG_ERROR(Kernel_SVC, "Expected info_type to be ProcessState but got {} instead", type);
        return ResultInvalidEnumValue;
    }

@@ -2722,14 +2701,24 @@ static Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr ou
    return ResultSuccess;
 }

-static Result FlushProcessDataCache32([[maybe_unused]] Core::System& system,
-                                      [[maybe_unused]] Handle handle, [[maybe_unused]] u32 address,
-                                      [[maybe_unused]] u32 size) {
-    // Note(Blinkhawk): For emulation purposes of the data cache this is mostly a no-op,
-    // as all emulation is done in the same cache level in host architecture, thus data cache
-    // does not need flushing.
-    LOG_DEBUG(Kernel_SVC, "called");
-    return ResultSuccess;
+static Result FlushProcessDataCache32(Core::System& system, Handle process_handle, u64 address,
+                                      u64 size) {
+    // Validate address/size.
+    R_UNLESS(size > 0, ResultInvalidSize);
+    R_UNLESS(address == static_cast<uintptr_t>(address), ResultInvalidCurrentMemory);
+    R_UNLESS(size == static_cast<size_t>(size), ResultInvalidCurrentMemory);
+
+    // Get the process from its handle.
+    KScopedAutoObject process =
+        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
+    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
+
+    // Verify the region is within range.
+    auto& page_table = process->PageTable();
+    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
+
+    // Perform the operation.
+    R_RETURN(system.Memory().FlushDataCache(*process, address, size));
 }

 namespace {
@@ -8,6 +8,8 @@

 namespace Kernel::Svc {

+using Handle = u32;
+
 enum class MemoryState : u32 {
    Free = 0x00,
    Io = 0x01,
@@ -55,17 +57,6 @@ enum class MemoryPermission : u32 {
 };
 DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission);

-struct MemoryInfo {
-    u64 addr{};
-    u64 size{};
-    MemoryState state{};
-    MemoryAttribute attr{};
-    MemoryPermission perm{};
-    u32 ipc_refcount{};
-    u32 device_refcount{};
-    u32 padding{};
-};
-
 enum class SignalType : u32 {
    Signal = 0,
    SignalAndIncrementIfEqual = 1,
@@ -124,7 +115,57 @@ enum class ProcessExitReason : u32 {

 constexpr inline size_t ThreadLocalRegionSize = 0x200;

-// Debug types.
+struct PageInfo {
+    u32 flags;
+};
+
+// Info Types.
+enum class InfoType : u32 {
+    CoreMask = 0,
+    PriorityMask = 1,
+    AliasRegionAddress = 2,
+    AliasRegionSize = 3,
+    HeapRegionAddress = 4,
+    HeapRegionSize = 5,
+    TotalMemorySize = 6,
+    UsedMemorySize = 7,
+    DebuggerAttached = 8,
+    ResourceLimit = 9,
+    IdleTickCount = 10,
+    RandomEntropy = 11,
+    AslrRegionAddress = 12,
+    AslrRegionSize = 13,
+    StackRegionAddress = 14,
+    StackRegionSize = 15,
+    SystemResourceSizeTotal = 16,
+    SystemResourceSizeUsed = 17,
+    ProgramId = 18,
+    InitialProcessIdRange = 19,
+    UserExceptionContextAddress = 20,
+    TotalNonSystemMemorySize = 21,
+    UsedNonSystemMemorySize = 22,
+    IsApplication = 23,
+    FreeThreadCount = 24,
+    ThreadTickCount = 25,
+    IsSvcPermitted = 26,
+
+    MesosphereMeta = 65000,
+    MesosphereCurrentProcess = 65001,
+};
+
+enum class BreakReason : u32 {
+    Panic = 0,
+    Assert = 1,
+    User = 2,
+    PreLoadDll = 3,
+    PostLoadDll = 4,
+    PreUnloadDll = 5,
+    PostUnloadDll = 6,
+    CppException = 7,
+
+    NotificationOnlyFlag = 0x80000000,
+};
+
 enum class DebugEvent : u32 {
    CreateProcess = 0,
    CreateThread = 1,
@@ -133,6 +174,14 @@ enum class DebugEvent : u32 {
    Exception = 4,
 };

+enum class DebugThreadParam : u32 {
+    Priority = 0,
+    State = 1,
+    IdealCore = 2,
+    CurrentCore = 3,
+    AffinityMask = 4,
+};
+
 enum class DebugException : u32 {
    UndefinedInstruction = 0,
    InstructionAbort = 1,
@@ -146,4 +195,401 @@ enum class DebugException : u32 {
    MemorySystemError = 9,
 };

+enum class DebugEventFlag : u32 {
+    Stopped = (1u << 0),
+};
+
+enum class BreakPointType : u32 {
+    HardwareInstruction = 0,
+    HardwareData = 1,
+};
+
+enum class HardwareBreakPointRegisterName : u32 {
+    I0 = 0,
+    I1 = 1,
+    I2 = 2,
+    I3 = 3,
+    I4 = 4,
+    I5 = 5,
+    I6 = 6,
+    I7 = 7,
+    I8 = 8,
+    I9 = 9,
+    I10 = 10,
+    I11 = 11,
+    I12 = 12,
+    I13 = 13,
+    I14 = 14,
+    I15 = 15,
+    D0 = 16,
+    D1 = 17,
+    D2 = 18,
+    D3 = 19,
+    D4 = 20,
+    D5 = 21,
+    D6 = 22,
+    D7 = 23,
+    D8 = 24,
+    D9 = 25,
+    D10 = 26,
+    D11 = 27,
+    D12 = 28,
+    D13 = 29,
+    D14 = 30,
+    D15 = 31,
+};
+
+namespace lp64 {
+struct LastThreadContext {
+    u64 fp;
+    u64 sp;
+    u64 lr;
+    u64 pc;
+};
+
+struct PhysicalMemoryInfo {
+    PAddr physical_address;
+    u64 virtual_address;
+    u64 size;
+};
+
+struct DebugInfoCreateProcess {
+    u64 program_id;
+    u64 process_id;
+    std::array<char, 0xC> name;
+    u32 flags;
+    u64 user_exception_context_address; // 5.0.0+
+};
+
+struct DebugInfoCreateThread {
+    u64 thread_id;
+    u64 tls_address;
+    // Removed in 11.0.0 u64 entrypoint;
+};
+
+struct DebugInfoExitProcess {
+    ProcessExitReason reason;
+};
+
+struct DebugInfoExitThread {
+    ThreadExitReason reason;
+};
+
+struct DebugInfoUndefinedInstructionException {
+    u32 insn;
+};
+
+struct DebugInfoDataAbortException {
+    u64 address;
+};
+
+struct DebugInfoAlignmentFaultException {
+    u64 address;
+};
+
+struct DebugInfoBreakPointException {
+    BreakPointType type;
+    u64 address;
+};
+
+struct DebugInfoUserBreakException {
+    BreakReason break_reason;
+    u64 address;
+    u64 size;
+};
+
+struct DebugInfoDebuggerBreakException {
+    std::array<u64, 4> active_thread_ids;
+};
+
+struct DebugInfoUndefinedSystemCallException {
+    u32 id;
+};
+
+union DebugInfoSpecificException {
+    DebugInfoUndefinedInstructionException undefined_instruction;
+    DebugInfoDataAbortException data_abort;
+    DebugInfoAlignmentFaultException alignment_fault;
+    DebugInfoBreakPointException break_point;
+    DebugInfoUserBreakException user_break;
+    DebugInfoDebuggerBreakException debugger_break;
+    DebugInfoUndefinedSystemCallException undefined_system_call;
+    u64 raw;
+};
+
+struct DebugInfoException {
+    DebugException type;
+    u64 address;
+    DebugInfoSpecificException specific;
+};
+
+union DebugInfo {
+    DebugInfoCreateProcess create_process;
+    DebugInfoCreateThread create_thread;
+    DebugInfoExitProcess exit_process;
+    DebugInfoExitThread exit_thread;
+    DebugInfoException exception;
+};
+
+struct DebugEventInfo {
+    DebugEvent type;
+    u32 flags;
+    u64 thread_id;
+    DebugInfo info;
+};
+static_assert(sizeof(DebugEventInfo) >= 0x40);
+
+struct SecureMonitorArguments {
+    std::array<u64, 8> r;
+};
+static_assert(sizeof(SecureMonitorArguments) == 0x40);
+} // namespace lp64
+
+namespace ilp32 {
+struct LastThreadContext {
+    u32 fp;
+    u32 sp;
+    u32 lr;
+    u32 pc;
+};
+
+struct PhysicalMemoryInfo {
+    PAddr physical_address;
+    u32 virtual_address;
+    u32 size;
+};
+
+struct DebugInfoCreateProcess {
+    u64 program_id;
+    u64 process_id;
+    std::array<char, 0xC> name;
+    u32 flags;
+    u32 user_exception_context_address; // 5.0.0+
+};
+
+struct DebugInfoCreateThread {
+    u64 thread_id;
+    u32 tls_address;
+    // Removed in 11.0.0 u32 entrypoint;
+};
+
+struct DebugInfoExitProcess {
+    ProcessExitReason reason;
+};
+
+struct DebugInfoExitThread {
+    ThreadExitReason reason;
+};
+
+struct DebugInfoUndefinedInstructionException {
+    u32 insn;
+};
+
+struct DebugInfoDataAbortException {
+    u32 address;
+};
+
+struct DebugInfoAlignmentFaultException {
+    u32 address;
+};
+
+struct DebugInfoBreakPointException {
+    BreakPointType type;
+    u32 address;
+};
+
+struct DebugInfoUserBreakException {
+    BreakReason break_reason;
+    u32 address;
+    u32 size;
+};
+
+struct DebugInfoDebuggerBreakException {
+    std::array<u64, 4> active_thread_ids;
+};
+
+struct DebugInfoUndefinedSystemCallException {
+    u32 id;
+};
+
+union DebugInfoSpecificException {
+    DebugInfoUndefinedInstructionException undefined_instruction;
+    DebugInfoDataAbortException data_abort;
+    DebugInfoAlignmentFaultException alignment_fault;
+    DebugInfoBreakPointException break_point;
+    DebugInfoUserBreakException user_break;
+    DebugInfoDebuggerBreakException debugger_break;
+    DebugInfoUndefinedSystemCallException undefined_system_call;
+    u64 raw;
+};
+
+struct DebugInfoException {
+    DebugException type;
+    u32 address;
+    DebugInfoSpecificException specific;
+};
+
+union DebugInfo {
+    DebugInfoCreateProcess create_process;
+    DebugInfoCreateThread create_thread;
+    DebugInfoExitProcess exit_process;
+    DebugInfoExitThread exit_thread;
+    DebugInfoException exception;
+};
+
+struct DebugEventInfo {
+    DebugEvent type;
+    u32 flags;
+    u64 thread_id;
+    DebugInfo info;
+};
+
+struct SecureMonitorArguments {
+    std::array<u32, 8> r;
+};
+static_assert(sizeof(SecureMonitorArguments) == 0x20);
+} // namespace ilp32
+
+struct ThreadContext {
+    std::array<u64, 29> r;
+    u64 fp;
+    u64 lr;
+    u64 sp;
+    u64 pc;
+    u32 pstate;
+    u32 padding;
+    std::array<u128, 32> v;
+    u32 fpcr;
+    u32 fpsr;
+    u64 tpidr;
+};
+static_assert(sizeof(ThreadContext) == 0x320);
+
+struct MemoryInfo {
+    u64 base_address;
+    u64 size;
+    MemoryState state;
+    MemoryAttribute attribute;
+    MemoryPermission permission;
+    u32 ipc_count;
+    u32 device_count;
+    u32 padding;
+};
+
+enum class LimitableResource : u32 {
+    PhysicalMemoryMax = 0,
+    ThreadCountMax = 1,
+    EventCountMax = 2,
+    TransferMemoryCountMax = 3,
+    SessionCountMax = 4,
+    Count,
+};
+
+enum class IoPoolType : u32 {
+    // Not supported.
+    Count = 0,
+};
+
+enum class MemoryMapping : u32 {
+    IoRegister = 0,
+    Uncached = 1,
+    Memory = 2,
+};
+
+enum class KernelDebugType : u32 {
+    Thread = 0,
+    ThreadCallStack = 1,
+    KernelObject = 2,
+    Handle_ = 3,
+    Memory = 4,
+    PageTable = 5,
+    CpuUtilization = 6,
+    Process = 7,
+    SuspendProcess = 8,
+    ResumeProcess = 9,
+    Port = 10,
+};
+
+enum class KernelTraceState : u32 {
+    Disabled = 0,
+    Enabled = 1,
+};
+
+enum class CodeMemoryOperation : u32 {
+    Map = 0,
+    MapToOwner = 1,
+    Unmap = 2,
+    UnmapFromOwner = 3,
+};
+
+enum class InterruptType : u32 {
+    Edge = 0,
+    Level = 1,
+};
+
+enum class DeviceName {
+    Afi = 0,
+    Avpc = 1,
+    Dc = 2,
+    Dcb = 3,
+    Hc = 4,
+    Hda = 5,
+    Isp2 = 6,
+    MsencNvenc = 7,
+    Nv = 8,
+    Nv2 = 9,
+    Ppcs = 10,
+    Sata = 11,
+    Vi = 12,
+    Vic = 13,
+    XusbHost = 14,
+    XusbDev = 15,
+    Tsec = 16,
+    Ppcs1 = 17,
+    Dc1 = 18,
+    Sdmmc1a = 19,
+    Sdmmc2a = 20,
+    Sdmmc3a = 21,
+    Sdmmc4a = 22,
+    Isp2b = 23,
+    Gpu = 24,
+    Gpub = 25,
+    Ppcs2 = 26,
+    Nvdec = 27,
+    Ape = 28,
+    Se = 29,
+    Nvjpg = 30,
+    Hc1 = 31,
+    Se1 = 32,
+    Axiap = 33,
+    Etr = 34,
+    Tsecb = 35,
+    Tsec1 = 36,
+    Tsecb1 = 37,
+    Nvdec1 = 38,
+    Count,
+};
+
+enum class SystemInfoType : u32 {
+    TotalPhysicalMemorySize = 0,
+    UsedPhysicalMemorySize = 1,
+    InitialProcessIdRange = 2,
+};
+
+enum class ProcessInfoType : u32 {
+    ProcessState = 0,
+};
+
+struct CreateProcessParameter {
+    std::array<char, 12> name;
+    u32 version;
+    u64 program_id;
+    u64 code_address;
+    s32 code_num_pages;
+    u32 flags;
+    Handle reslimit;
+    s32 system_resource_num_pages;
+};
+static_assert(sizeof(CreateProcessParameter) == 0x30);
+
 } // namespace Kernel::Svc
@@ -722,4 +722,12 @@ void SvcWrap32(Core::System& system) {
    FuncReturn(system, retval);
 }

+// Used by Invalidate/Store/FlushProcessDataCache32
+template <Result func(Core::System&, Handle, u64, u64)>
+void SvcWrap32(Core::System& system) {
+    const u64 address = (Param(system, 3) << 32) | Param(system, 2);
+    const u64 size = (Param(system, 4) << 32) | Param(system, 1);
+    FuncReturn32(system, func(system, Param32(system, 0), address, size).raw);
+}
+
 } // namespace Kernel
@@ -28,30 +28,49 @@ enum class ErrorModule : u32 {
    Loader = 9,
    CMIF = 10,
    HIPC = 11,
+    TMA = 12,
+    DMNT = 13,
+    GDS = 14,
    PM = 15,
    NS = 16,
+    BSDSockets = 17,
    HTC = 18,
+    TSC = 19,
    NCMContent = 20,
    SM = 21,
    RO = 22,
+    GC = 23,
    SDMMC = 24,
    OVLN = 25,
    SPL = 26,
+    Socket = 27,
+    HTCLOW = 29,
+    DDSF = 30,
+    HTCFS = 31,
+    Async = 32,
+    Util = 33,
+    TIPC = 35,
+    ANIF = 37,
    ETHC = 100,
    I2C = 101,
    GPIO = 102,
    UART = 103,
+    CPAD = 104,
    Settings = 105,
+    FTM = 106,
    WLAN = 107,
    XCD = 108,
+    TMP451 = 109,
    NIFM = 110,
    Hwopus = 111,
+    LSM6DS3 = 112,
    Bluetooth = 113,
    VI = 114,
    NFP = 115,
    Time = 116,
    FGM = 117,
    OE = 118,
+    BH1730FVC = 119,
    PCIe = 120,
    Friends = 121,
    BCAT = 122,
@@ -65,7 +84,7 @@ enum class ErrorModule : u32 {
    AHID = 130,
    Qlaunch = 132,
    PCV = 133,
-    OMM = 134,
+    USBPD = 134,
    BPC = 135,
    PSM = 136,
    NIM = 137,
@@ -75,18 +94,22 @@ enum class ErrorModule : u32 {
    NSD = 141,
    PCTL = 142,
    BTM = 143,
+    LA = 144,
    ETicket = 145,
    NGC = 146,
    ERPT = 147,
    APM = 148,
+    CEC = 149,
    Profiler = 150,
    ErrorUpload = 151,
+    LIDBE = 152,
    Audio = 153,
    NPNS = 154,
    NPNSHTTPSTREAM = 155,
    ARP = 157,
    SWKBD = 158,
    BOOT = 159,
+    NetDiag = 160,
    NFCMifare = 161,
    UserlandAssert = 162,
    Fatal = 163,
@@ -94,17 +117,68 @@ enum class ErrorModule : u32 {
    SPSM = 165,
    BGTC = 167,
    UserlandCrash = 168,
+    SASBUS = 169,
+    PI = 170,
+    AudioCtrl = 172,
+    LBL = 173,
+    JIT = 175,
+    HDCP = 176,
+    OMM = 177,
+    PDM = 178,
+    OLSC = 179,
    SREPO = 180,
    Dauth = 181,
+    STDFU = 182,
+    DBG = 183,
+    DHCPS = 186,
+    SPI = 187,
+    AVM = 188,
+    PWM = 189,
+    RTC = 191,
+    Regulator = 192,
+    LED = 193,
+    SIO = 195,
+    PCM = 196,
+    CLKRST = 197,
+    POWCTL = 198,
+    AudioOld = 201,
    HID = 202,
    LDN = 203,
+    CS = 204,
    Irsensor = 205,
    Capture = 206,
    Manu = 208,
    ATK = 209,
+    WEB = 210,
+    LCS = 211,
    GRC = 212,
+    Repair = 213,
+    Album = 214,
+    RID = 215,
    Migration = 216,
    MigrationLdcServ = 217,
+    HIDBUS = 218,
+    ENS = 219,
+    WebSocket = 223,
+    DCDMTP = 227,
+    PGL = 228,
+    Notification = 229,
+    INS = 230,
+    LP2P = 231,
+    RCD = 232,
+    LCM40607 = 233,
+    PRC = 235,
+    TMAHTC = 237,
+    ECTX = 238,
+    MNPP = 239,
+    HSHL = 240,
+    CAPMTP = 242,
+    DP2HDMI = 244,
+    Cradle = 245,
+    SProfile = 246,
+    NDRM = 250,
+    TSPM = 499,
+    DevMenu = 500,
    GeneralWebApplet = 800,
    WifiWebAuthApplet = 809,
    WhitelistedApplet = 810,
@@ -0,0 +1,177 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/frontend/applets/cabinet.h"
+#include "core/hid/hid_core.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/applet_cabinet.h"
+#include "core/hle/service/mii/mii_manager.h"
+#include "core/hle/service/nfp/nfp_device.h"
+
+namespace Service::AM::Applets {
+
+Cabinet::Cabinet(Core::System& system_, LibraryAppletMode applet_mode_,
+                 const Core::Frontend::CabinetApplet& frontend_)
+    : Applet{system_, applet_mode_}, frontend{frontend_}, system{system_}, service_context{
+                                                                               system_,
+                                                                               "CabinetApplet"} {
+
+    availability_change_event =
+        service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent");
+}
+
+Cabinet::~Cabinet() = default;
+
+void Cabinet::Initialize() {
+    Applet::Initialize();
+
+    LOG_INFO(Service_HID, "Initializing Cabinet Applet.");
+
+    LOG_DEBUG(Service_HID,
+              "Initializing Applet with common_args: arg_version={}, lib_version={}, "
+              "play_startup_sound={}, size={}, system_tick={}, theme_color={}",
+              common_args.arguments_version, common_args.library_version,
+              common_args.play_startup_sound, common_args.size, common_args.system_tick,
+              common_args.theme_color);
+
+    const auto storage = broker.PopNormalDataToApplet();
+    ASSERT(storage != nullptr);
+
+    const auto applet_input_data = storage->GetData();
+    ASSERT(applet_input_data.size() >= sizeof(StartParamForAmiiboSettings));
+
+    std::memcpy(&applet_input_common, applet_input_data.data(),
+                sizeof(StartParamForAmiiboSettings));
+}
+
+bool Cabinet::TransactionComplete() const {
+    return is_complete;
+}
+
+Result Cabinet::GetStatus() const {
+    return ResultSuccess;
+}
+
+void Cabinet::ExecuteInteractive() {
+    ASSERT_MSG(false, "Attempted to call interactive execution on non-interactive applet.");
+}
+
+void Cabinet::Execute() {
+    if (is_complete) {
+        return;
+    }
+
+    const auto callback = [this](bool apply_changes, const std::string& amiibo_name) {
+        DisplayCompleted(apply_changes, amiibo_name);
+    };
+
+    // TODO: listen on all controllers
+    if (nfp_device == nullptr) {
+        nfp_device = std::make_shared<Service::NFP::NfpDevice>(
+            system.HIDCore().GetFirstNpadId(), system, service_context, availability_change_event);
+        nfp_device->Initialize();
+        nfp_device->StartDetection(Service::NFP::TagProtocol::All);
+    }
+
+    const Core::Frontend::CabinetParameters parameters{
+        .tag_info = applet_input_common.tag_info,
+        .register_info = applet_input_common.register_info,
+        .mode = applet_input_common.applet_mode,
+    };
+
+    switch (applet_input_common.applet_mode) {
+    case Service::NFP::CabinetMode::StartNicknameAndOwnerSettings:
+    case Service::NFP::CabinetMode::StartGameDataEraser:
+    case Service::NFP::CabinetMode::StartRestorer:
+    case Service::NFP::CabinetMode::StartFormatter:
+        frontend.ShowCabinetApplet(callback, parameters, nfp_device);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unknown CabinetMode={}", applet_input_common.applet_mode);
+        DisplayCompleted(false, {});
+        break;
+    }
+}
+
+void Cabinet::DisplayCompleted(bool apply_changes, std::string_view amiibo_name) {
+    Service::Mii::MiiManager manager;
+    ReturnValueForAmiiboSettings applet_output{};
+
+    if (!apply_changes) {
+        Cancel();
+    }
+
+    if (nfp_device->GetCurrentState() != Service::NFP::DeviceState::TagFound &&
+        nfp_device->GetCurrentState() != Service::NFP::DeviceState::TagMounted) {
+        Cancel();
+    }
+
+    if (nfp_device->GetCurrentState() == Service::NFP::DeviceState::TagFound) {
+        nfp_device->Mount(Service::NFP::MountTarget::All);
+    }
+
+    switch (applet_input_common.applet_mode) {
+    case Service::NFP::CabinetMode::StartNicknameAndOwnerSettings: {
+        Service::NFP::AmiiboName name{};
+        std::memcpy(name.data(), amiibo_name.data(), std::min(amiibo_name.size(), name.size() - 1));
+        nfp_device->SetNicknameAndOwner(name);
+        break;
+    }
+    case Service::NFP::CabinetMode::StartGameDataEraser:
+        nfp_device->DeleteApplicationArea();
+        break;
+    case Service::NFP::CabinetMode::StartRestorer:
+        nfp_device->RestoreAmiibo();
+        break;
+    case Service::NFP::CabinetMode::StartFormatter:
+        nfp_device->DeleteAllData();
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unknown CabinetMode={}", applet_input_common.applet_mode);
+        break;
+    }
+
+    applet_output.device_handle = applet_input_common.device_handle;
+    applet_output.result = CabinetResult::Cancel;
+    const auto reg_result = nfp_device->GetRegisterInfo(applet_output.register_info);
+    const auto tag_result = nfp_device->GetTagInfo(applet_output.tag_info);
+    nfp_device->Finalize();
+
+    if (reg_result.IsSuccess()) {
+        applet_output.result |= CabinetResult::RegisterInfo;
+    }
+
+    if (tag_result.IsSuccess()) {
+        applet_output.result |= CabinetResult::TagInfo;
+    }
+
+    std::vector<u8> out_data(sizeof(ReturnValueForAmiiboSettings));
+    std::memcpy(out_data.data(), &applet_output, sizeof(ReturnValueForAmiiboSettings));
+
+    is_complete = true;
+
+    broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::move(out_data)));
+    broker.SignalStateChanged();
+}
+
+void Cabinet::Cancel() {
+    ReturnValueForAmiiboSettings applet_output{};
+    applet_output.device_handle = applet_input_common.device_handle;
+    applet_output.result = CabinetResult::Cancel;
+    nfp_device->Finalize();
+
+    std::vector<u8> out_data(sizeof(ReturnValueForAmiiboSettings));
+    std::memcpy(out_data.data(), &applet_output, sizeof(ReturnValueForAmiiboSettings));
+
+    is_complete = true;
+
+    broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::move(out_data)));
+    broker.SignalStateChanged();
+}
+
+} // namespace Service::AM::Applets
@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "core/hle/result.h"
+#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/nfp/nfp_types.h"
+
+namespace Kernel {
+class KEvent;
+class KReadableEvent;
+} // namespace Kernel
+
+namespace Core {
+class System;
+} // namespace Core
+
+namespace Service::NFP {
+class NfpDevice;
+}
+
+namespace Service::AM::Applets {
+
+enum class CabinetAppletVersion : u32 {
+    Version1 = 0x1,
+};
+
+enum class CabinetResult : u8 {
+    Cancel = 0,
+    TagInfo = 1 << 1,
+    RegisterInfo = 1 << 2,
+    All = TagInfo | RegisterInfo,
+};
+DECLARE_ENUM_FLAG_OPERATORS(CabinetResult)
+
+// This is nn::nfp::AmiiboSettingsStartParam
+struct AmiiboSettingsStartParam {
+    u64 device_handle;
+    std::array<u8, 0x20> param_1;
+    u8 param_2;
+};
+static_assert(sizeof(AmiiboSettingsStartParam) == 0x30,
+              "AmiiboSettingsStartParam is an invalid size");
+
+#pragma pack(push, 1)
+// This is nn::nfp::StartParamForAmiiboSettings
+struct StartParamForAmiiboSettings {
+    u8 param_1;
+    Service::NFP::CabinetMode applet_mode;
+    u8 flags;
+    u8 amiibo_settings_1;
+    u64 device_handle;
+    Service::NFP::TagInfo tag_info;
+    Service::NFP::RegisterInfo register_info;
+    std::array<u8, 0x20> amiibo_settings_3;
+    INSERT_PADDING_BYTES(0x24);
+};
+static_assert(sizeof(StartParamForAmiiboSettings) == 0x1A8,
+              "StartParamForAmiiboSettings is an invalid size");
+
+// This is nn::nfp::ReturnValueForAmiiboSettings
+struct ReturnValueForAmiiboSettings {
+    CabinetResult result;
+    INSERT_PADDING_BYTES(0x3);
+    u64 device_handle;
+    Service::NFP::TagInfo tag_info;
+    Service::NFP::RegisterInfo register_info;
+    INSERT_PADDING_BYTES(0x24);
+};
+static_assert(sizeof(ReturnValueForAmiiboSettings) == 0x188,
+              "ReturnValueForAmiiboSettings is an invalid size");
+#pragma pack(pop)
+
+class Cabinet final : public Applet {
+public:
+    explicit Cabinet(Core::System& system_, LibraryAppletMode applet_mode_,
+                     const Core::Frontend::CabinetApplet& frontend_);
+    ~Cabinet() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    Result GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+    void DisplayCompleted(bool apply_changes, std::string_view amiibo_name);
+    void Cancel();
+
+private:
+    const Core::Frontend::CabinetApplet& frontend;
+    Core::System& system;
+
+    bool is_complete{false};
+    std::shared_ptr<Service::NFP::NfpDevice> nfp_device;
+    Kernel::KEvent* availability_change_event;
+    KernelHelpers::ServiceContext service_context;
+    StartParamForAmiiboSettings applet_input_common{};
+};
+
+} // namespace Service::AM::Applets
@@ -144,6 +144,7 @@ void Error::Initialize() {
        break;
    default:
        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", mode);
+        break;
    }
 }

--- a/Show More
+++ b/Show More