build(externals): move to MbedTLS upstream 2.28.1

The latest LTS release now includes the changes of the yuzu-emu fork, so we can now directly use the upstream version instead.
build: use system MbedTLS when available
2023-01-07 18:07:56 +01:00 · 2023-01-07 18:07:42 +01:00 · 2023-01-07 10:41:37 -06:00 · 2023-01-07 10:40:21 -06:00 · 2023-01-06 21:23:21 -05:00 · 2023-01-06 19:07:47 -05:00
276 changed files with 38520 additions and 16810 deletions
@@ -11,6 +11,7 @@ ccache -s
 mkdir build || true && cd build
 cmake .. \
      -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_CXX_FLAGS="-march=x86-64-v2" \
      -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ \
      -DCMAKE_C_COMPILER=/usr/lib/ccache/clang \
      -DCMAKE_INSTALL_PREFIX="/usr" \
@@ -10,7 +10,7 @@ if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* dis
 fi

 # Default clang-format points to default 3.5 version one
-CLANG_FORMAT=clang-format-12
+CLANG_FORMAT=${CLANG_FORMAT:-clang-format-12}
 $CLANG_FORMAT --version

 if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then
@@ -12,6 +12,7 @@ mkdir build || true && cd build
 cmake .. \
      -DBoost_USE_STATIC_LIBS=ON \
      -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_CXX_FLAGS="-march=x86-64-v2" \
      -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ \
      -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc \
      -DCMAKE_INSTALL_PREFIX="/usr" \
@@ -9,7 +9,7 @@ parameters:
 steps:
 - script: choco install vulkan-sdk
  displayName: 'Install vulkan-sdk'
- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 17 2022" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw /GA /Gr /Ob2" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
@@ -30,7 +30,7 @@
    url = https://github.com/yuzu-emu/sirit
 [submodule "mbedtls"]
    path = externals/mbedtls
-    url = https://github.com/yuzu-emu/mbedtls
+    url = https://github.com/Mbed-TLS/mbedtls
 [submodule "xbyak"]
    path = externals/xbyak
    url = https://github.com/herumi/xbyak.git
@@ -3,13 +3,8 @@

 cmake_minimum_required(VERSION 3.22)

-# Dynarmic has cmake_minimum_required(3.12) and we may want to override
-# some of its variables, which is only possible in 3.13+
-set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
-
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/find-modules")
 include(DownloadExternals)
 include(CMakeDependentOption)

@@ -22,6 +17,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)

+option(ENABLE_LIBUSB "Enable the use of LibUSB" ON)
+
 option(ENABLE_OPENGL "Enable OpenGL" ON)
 mark_as_advanced(FORCE ENABLE_OPENGL)
 option(ENABLE_QT "Enable the Qt frontend" ON)
@@ -35,6 +32,8 @@ option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)

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

+option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ON)
+
 option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)

 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
@@ -47,12 +46,16 @@ option(YUZU_TESTS "Compile tests" ON)

 option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)

+option(YUZU_ROOM "Compile LDN room server" ON)
+
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile Windows crash dump (Minidump) support" OFF "WIN32" OFF)

 option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")

 option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)

+CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
+
 if (YUZU_USE_BUNDLED_VCPKG)
    if (YUZU_TESTS)
        list(APPEND VCPKG_MANIFEST_FEATURES "yuzu-tests")
@@ -199,36 +202,43 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 # System imported libraries
 # =======================================================================

-find_package(enet 1.3)
+# Enforce the search mode of non-required packages for better and shorter failure messages
+find_package(enet 1.3 MODULE)
 find_package(fmt 9 REQUIRED)
-find_package(inih)
-find_package(libusb 1.0.24)
+find_package(inih MODULE)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
-find_package(Opus 1.3)
-find_package(Vulkan 1.3.213)
+find_package(Opus 1.3 MODULE)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)

+if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
+    find_package(Vulkan 1.3.238 REQUIRED)
+endif()
+
+if (ENABLE_LIBUSB)
+    find_package(libusb 1.0.24 MODULE)
+endif()
+
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    find_package(xbyak 6)
+    find_package(xbyak 6 CONFIG)
 endif()

 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
-    find_package(dynarmic 6.4.0)
+    find_package(dynarmic 6.4.0 CONFIG)
 endif()

 if (ENABLE_CUBEB)
-    find_package(cubeb)
+    find_package(cubeb CONFIG)
 endif()

 if (USE_DISCORD_PRESENCE)
-    find_package(DiscordRPC)
+    find_package(DiscordRPC MODULE)
 endif()

 if (ENABLE_WEB_SERVICE)
-    find_package(cpp-jwt 1.4)
-    find_package(httplib 0.11)
+    find_package(cpp-jwt 1.4 CONFIG)
+    find_package(httplib 0.11 MODULE)
 endif()

 if (YUZU_TESTS)
@@ -581,6 +591,21 @@ if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
    )
 endif()

+if (YUZU_USE_FASTER_LD AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # We will assume that if the compiler is GCC, it will attempt to use ld.bfd by default.
+    # Try to pick a faster linker.
+    find_program(LLD lld)
+    find_program(MOLD mold)
+
+    if (MOLD AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1")
+        message(NOTICE "Selecting mold as linker")
+        add_link_options("-fuse-ld=mold")
+    elseif (LLD)
+        message(NOTICE "Selecting lld as linker")
+        add_link_options("-fuse-ld=lld")
+    endif()
+endif()
+
 enable_testing()
 add_subdirectory(externals)
 add_subdirectory(src)
@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: 2021 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# MbedTLS 3.0.0 will ship with a CMake package config file,
+# see ARMmbed/mbedtls@d259e347e6e3a630acfc1a811709ca05e5d3b92e,
+# so when yuzu will switch to that version this won't be required anymore.
+#
+# yuzu only uses mbedcrypto, searching for mbedtls and mbedx509 is not
+# needed.
+
+find_path(MbedTLS_INCLUDE_DIR mbedtls/cipher.h)
+
+find_library(MbedTLS_LIBRARY mbedcrypto)
+
+if (MbedTLS_INCLUDE_DIR AND MbedTLS_LIBRARY)
+    # Check for CMAC support
+    include(CheckSymbolExists)
+    set(CMAKE_REQUIRED_LIBRARIES ${MbedTLS_LIBRARY})
+    check_symbol_exists(mbedtls_cipher_cmac ${MbedTLS_INCLUDE_DIR}/mbedtls/cmac.h mbedcrypto_HAS_CMAC)
+    unset(CMAKE_REQUIRED_LIBRARIES)
+
+    # Check if version 2.x is available
+    file(READ "${MbedTLS_INCLUDE_DIR}/mbedtls/version.h" MbedTLS_VERSION_FILE)
+    string(REGEX MATCH "#define[ ]+MBEDTLS_VERSION_STRING[ ]+\"([0-9.]+)\"" _ ${MbedTLS_VERSION_FILE})
+    set(MbedTLS_VERSION "${CMAKE_MATCH_1}")
+
+    if (NOT TARGET MbedTLS::mbedcrypto)
+        add_library(MbedTLS::mbedcrypto UNKNOWN IMPORTED GLOBAL)
+        set_target_properties(MbedTLS::mbedcrypto PROPERTIES
+            IMPORTED_LOCATION "${MbedTLS_LIBRARY}"
+            INTERFACE_INCLUDE_DIRECTORIES "${MbedTLS_INCLUDE_DIR}"
+        )
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MbedTLS
+    REQUIRED_VARS
+        MbedTLS_LIBRARY
+        MbedTLS_INCLUDE_DIR
+        mbedcrypto_HAS_CMAC
+    VERSION_VAR MbedTLS_VERSION
+)
@@ -2,9 +2,7 @@
 # SPDX-License-Identifier: GPL-2.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
-endif()
+pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Opus
@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(ENET QUIET IMPORTED_TARGET libenet)
-endif()
+pkg_search_module(ENET QUIET IMPORTED_TARGET libenet)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(enet
@@ -5,13 +5,11 @@
 include(FindPackageHandleStandardArgs)

 find_package(httplib QUIET CONFIG)
-if (httplib_FOUND)
+if (httplib_CONSIDERED_CONFIGS)
    find_package_handle_standard_args(httplib CONFIG_MODE)
 else()
    find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET cpp-httplib)
-    endif()
+    pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET cpp-httplib)
    find_package_handle_standard_args(httplib
        REQUIRED_VARS HTTPLIB_INCLUDEDIR
        VERSION_VAR HTTPLIB_VERSION
@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
-endif()
+pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(inih
@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)
-endif()
+pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(libusb
@@ -4,13 +4,11 @@
 include(FindPackageHandleStandardArgs)

 find_package(lz4 QUIET CONFIG)
-if (lz4_FOUND)
+if (lz4_CONSIDERED_CONFIGS)
    find_package_handle_standard_args(lz4 CONFIG_MODE)
 else()
    find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
-    endif()
+    pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
    find_package_handle_standard_args(lz4
        REQUIRED_VARS LZ4_LINK_LIBRARIES
        VERSION_VAR LZ4_VERSION
@@ -4,13 +4,11 @@
 include(FindPackageHandleStandardArgs)

 find_package(zstd QUIET CONFIG)
-if (zstd_FOUND)
+if (zstd_CONSIDERED_CONFIGS)
    find_package_handle_standard_args(zstd CONFIG_MODE)
 else()
    find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
-    endif()
+    pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
    find_package_handle_standard_args(zstd
        REQUIRED_VARS ZSTD_LINK_LIBRARIES
        VERSION_VAR ZSTD_VERSION
@@ -1,9 +1,9 @@
 # SPDX-FileCopyrightText: 2016 Citra Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later

-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules")
-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/externals/find-modules")
-include(DownloadExternals)
+# Dynarmic has cmake_minimum_required(3.12) and we may want to override
+# some of its variables, which is only possible in 3.13+
+set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)

 # xbyak
 if ((ARCHITECTURE_x86 OR ARCHITECTURE_x86_64) AND NOT TARGET xbyak::xbyak)
@@ -12,8 +12,7 @@ endif()

 # Dynarmic
 if ((ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64) AND NOT TARGET dynarmic::dynarmic)
-    set(DYNARMIC_NO_BUNDLED_FMT ON)
-    set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
+    set(DYNARMIC_IGNORE_ASSERTS ON)
    add_subdirectory(dynarmic EXCLUDE_FROM_ALL)
    add_library(dynarmic::dynarmic ALIAS dynarmic)
 endif()
@@ -31,9 +30,23 @@ if (NOT TARGET inih::INIReader)
    add_subdirectory(inih)
 endif()

-# mbedtls
-add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
-target_include_directories(mbedtls PUBLIC ./mbedtls/include)
+# MbedTLS
+find_package(MbedTLS 2.16)
+if(NOT MbedTLS_FOUND)
+    message(STATUS "MbedTLS not found, falling back to externals")
+
+    set(ENABLE_PROGRAMS OFF CACHE BOOL "")
+    set(ENABLE_TESTING OFF CACHE BOOL "")
+
+    # Edit MbedTLS config header to enable CMAC
+    file(READ "./mbedtls/include/mbedtls/config.h" MbedTLS_CONFIG_FILE)
+    string(REPLACE "//#define MBEDTLS_CMAC_C" "#define MBEDTLS_CMAC_C" MbedTLS_CONFIG_FILE_CMAC "${MbedTLS_CONFIG_FILE}")
+    file(WRITE "./mbedtls/include/mbedtls/config.h" "${MbedTLS_CONFIG_FILE_CMAC}")
+
+    add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
+    target_include_directories(mbedcrypto PUBLIC ./mbedtls/include)
+    add_library(MbedTLS::mbedcrypto ALIAS mbedcrypto)
+endif()

 # MicroProfile
 add_library(microprofile INTERFACE)
@@ -45,7 +58,7 @@ if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12" AND CMAKE_CXX_COMPILER
 endif()

 # libusb
-if (NOT TARGET libusb::usb)
+if (ENABLE_LIBUSB AND NOT TARGET libusb::usb)
    add_subdirectory(libusb EXCLUDE_FROM_ALL)
 endif()

@@ -60,10 +73,10 @@ if (YUZU_USE_EXTERNAL_SDL2)
            Locale Power Render)
        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
          string(TOUPPER ${_SUB} _OPT)
-          option(SDL_${_OPT} "" OFF)
+          set(SDL_${_OPT} OFF)
        endforeach()

-        option(HIDAPI "" ON)
+        set(HIDAPI ON)
    endif()
    set(SDL_STATIC ON)
    set(SDL_SHARED OFF)
@@ -83,7 +96,7 @@ endif()

 # Cubeb
 if (ENABLE_CUBEB AND NOT TARGET cubeb::cubeb)
-    set(BUILD_TESTS OFF CACHE BOOL "")
+    set(BUILD_TESTS OFF)
    add_subdirectory(cubeb EXCLUDE_FROM_ALL)
    add_library(cubeb::cubeb ALIAS cubeb)
 endif()
@@ -98,6 +111,7 @@ endif()
 # Sirit
 add_subdirectory(sirit EXCLUDE_FROM_ALL)

+# httplib
 if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
    if (NOT WIN32)
        find_package(OpenSSL 1.1)
@@ -108,7 +122,7 @@ if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)

    if (WIN32 OR NOT OPENSSL_FOUND)
        # LibreSSL
-        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+        set(LIBRESSL_SKIP_INSTALL ON)
        set(OPENSSLDIR "/etc/ssl/")
        add_subdirectory(libressl EXCLUDE_FROM_ALL)
        target_include_directories(ssl INTERFACE ./libressl/include)
@@ -118,7 +132,6 @@ if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
            DEFINITION OPENSSL_LIBS)
    endif()

-    # httplib
    add_library(httplib INTERFACE)
    target_include_directories(httplib INTERFACE ./cpp-httplib)
    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
@@ -152,6 +165,6 @@ if (YUZU_USE_BUNDLED_FFMPEG)
 endif()

 # Vulkan-Headers
-if (NOT TARGET Vulkan::Headers)
+if (YUZU_USE_EXTERNAL_VULKAN_HEADERS)
    add_subdirectory(Vulkan-Headers EXCLUDE_FROM_ALL)
 endif()
@@ -161,7 +161,10 @@ add_subdirectory(video_core)
 add_subdirectory(network)
 add_subdirectory(input_common)
 add_subdirectory(shader_recompiler)
-add_subdirectory(dedicated_room)
+
+if (YUZU_ROOM)
+     add_subdirectory(dedicated_room)
+endif()

 if (YUZU_TESTS)
    add_subdirectory(tests)
@@ -187,11 +187,7 @@ add_library(audio_core STATIC
    renderer/voice/voice_info.cpp
    renderer/voice/voice_info.h
    renderer/voice/voice_state.h
-    sink/cubeb_sink.cpp
-    sink/cubeb_sink.h
    sink/null_sink.h
-    sink/sdl2_sink.cpp
-    sink/sdl2_sink.h
    sink/sink.h
    sink/sink_details.cpp
    sink/sink_details.h
@@ -222,11 +218,22 @@ if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
    target_link_libraries(audio_core PRIVATE dynarmic::dynarmic)
 endif()

-if(ENABLE_CUBEB)
+if (ENABLE_CUBEB)
+    target_sources(audio_core PRIVATE
+        sink/cubeb_sink.cpp
+        sink/cubeb_sink.h
+    )
+
    target_link_libraries(audio_core PRIVATE cubeb::cubeb)
    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
-if(ENABLE_SDL2)
+
+if (ENABLE_SDL2)
+    target_sources(audio_core PRIVATE
+        sink/sdl2_sink.cpp
+        sink/sdl2_sink.h
+    )
+
    target_link_libraries(audio_core PRIVATE SDL2::SDL2)
    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
@@ -91,9 +91,10 @@ public:
     * @param core_timing - The CoreTiming instance
     * @param session     - The device session
     *
-     * @return Is the buffer was released.
+     * @return If any buffer was released.
     */
-    bool ReleaseBuffers(const Core::Timing::CoreTiming& core_timing, const DeviceSession& session) {
+    bool ReleaseBuffers(const Core::Timing::CoreTiming& core_timing, const DeviceSession& session,
+                        bool force) {
        std::scoped_lock l{lock};
        bool buffer_released{false};
        while (registered_count > 0) {
@@ -103,7 +104,8 @@ public:
            }

            // Check with the backend if this buffer can be released yet.
-            if (!session.IsBufferConsumed(buffers[index])) {
+            // If we're shutting down, we don't care if it's been played or not.
+            if (!force && !session.IsBufferConsumed(buffers[index])) {
                break;
            }

@@ -73,6 +73,12 @@ void DeviceSession::Stop() {
    }
 }

+void DeviceSession::ClearBuffers() {
+    if (stream) {
+        stream->ClearQueue();
+    }
+}
+
 void DeviceSession::AppendBuffers(std::span<const AudioBuffer> buffers) const {
    for (const auto& buffer : buffers) {
        Sink::SinkBuffer new_buffer{
@@ -90,6 +90,11 @@ public:
     */
    void Stop();

+    /**
+     * Clear out the underlying audio buffers in the backend stream.
+     */
+    void ClearBuffers();
+
    /**
     * Set this device session's volume.
     *
@@ -23,7 +23,6 @@ System::~System() {
 void System::Finalize() {
    Stop();
    session->Finalize();
-    buffer_event->Signal();
 }

 void System::StartSession() {
@@ -102,6 +101,10 @@ Result System::Stop() {
    if (state == State::Started) {
        session->Stop();
        session->SetVolume(0.0f);
+        session->ClearBuffers();
+        if (buffers.ReleaseBuffers(system.CoreTiming(), *session, true)) {
+            buffer_event->Signal();
+        }
        state = State::Stopped;
    }

@@ -138,7 +141,7 @@ void System::RegisterBuffers() {
 }

 void System::ReleaseBuffers() {
-    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
+    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session, false)};

    if (signal) {
        // Signal if any buffer was released, or if none are registered, we need more.
@@ -24,7 +24,6 @@ System::~System() {
 void System::Finalize() {
    Stop();
    session->Finalize();
-    buffer_event->Signal();
 }

 std::string_view System::GetDefaultOutputDeviceName() const {
@@ -102,6 +101,10 @@ Result System::Stop() {
    if (state == State::Started) {
        session->Stop();
        session->SetVolume(0.0f);
+        session->ClearBuffers();
+        if (buffers.ReleaseBuffers(system.CoreTiming(), *session, true)) {
+            buffer_event->Signal();
+        }
        state = State::Stopped;
    }

@@ -138,7 +141,7 @@ void System::RegisterBuffers() {
 }

 void System::ReleaseBuffers() {
-    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
+    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session, false)};
    if (signal) {
        // Signal if any buffer was released, or if none are registered, we need more.
        buffer_event->Signal();
@@ -34,8 +34,6 @@ add_library(common STATIC
    bit_util.h
    cityhash.cpp
    cityhash.h
-    cache_management.cpp
-    cache_management.h
    common_funcs.h
    common_precompiled_headers.h
    common_types.h
@@ -80,6 +78,7 @@ add_library(common STATIC
    logging/types.h
    lz4_compression.cpp
    lz4_compression.h
+    make_unique_for_overwrite.h
    math_util.h
    memory_detect.cpp
    memory_detect.h
@@ -98,11 +97,13 @@ add_library(common STATIC
    point.h
    precompiled_headers.h
    quaternion.h
+    range_map.h
    reader_writer_queue.h
    ring_buffer.h
    ${CMAKE_CURRENT_BINARY_DIR}/scm_rev.cpp
    scm_rev.h
    scope_exit.h
+    scratch_buffer.h
    settings.cpp
    settings.h
    settings_input.cpp
@@ -69,7 +69,7 @@ void assert_fail_impl();
 #define ASSERT_OR_EXECUTE(_a_, _b_)                                                                \
    do {                                                                                           \
        ASSERT(_a_);                                                                               \
-        if (!(_a_)) {                                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
            _b_                                                                                    \
        }                                                                                          \
    } while (0)
@@ -78,7 +78,7 @@ void assert_fail_impl();
 #define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
    do {                                                                                           \
        ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
-        if (!(_a_)) {                                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
            _b_                                                                                    \
        }                                                                                          \
    } while (0)
@@ -1,59 +0,0 @@
-// 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
@@ -1,27 +0,0 @@
-// 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
@@ -393,12 +393,27 @@ public:
        }

        // Virtual memory initialization
-        virtual_base = static_cast<u8*>(
-            mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+#if defined(__FreeBSD__)
+        virtual_base =
+            static_cast<u8*>(mmap(nullptr, virtual_size, PROT_NONE,
+                                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_ALIGNED_SUPER, -1, 0));
+        if (virtual_base == MAP_FAILED) {
+            virtual_base = static_cast<u8*>(
+                mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+            if (virtual_base == MAP_FAILED) {
+                LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
+                throw std::bad_alloc{};
+            }
+        }
+#else
+        virtual_base = static_cast<u8*>(mmap(nullptr, virtual_size, PROT_NONE,
+                                             MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
        if (virtual_base == MAP_FAILED) {
            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
            throw std::bad_alloc{};
        }
+        madvise(virtual_base, virtual_size, MADV_HUGEPAGE);
+#endif

        good = true;
    }
@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace Common {
+
+template <class T>
+requires(!std::is_array_v<T>) std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+template <class T>
+requires std::is_unbounded_array_v<T> std::unique_ptr<T> make_unique_for_overwrite(std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+template <class T, class... Args>
+requires std::is_bounded_array_v<T>
+void make_unique_for_overwrite(Args&&...) = delete;
+
+} // namespace Common
@@ -0,0 +1,139 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <map>
+#include <type_traits>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+template <typename KeyTBase, typename ValueT>
+class RangeMap {
+private:
+    using KeyT =
+        std::conditional_t<std::is_signed_v<KeyTBase>, KeyTBase, std::make_signed_t<KeyTBase>>;
+
+public:
+    explicit RangeMap(ValueT null_value_) : null_value{null_value_} {
+        container.emplace(std::numeric_limits<KeyT>::min(), null_value);
+    };
+    ~RangeMap() = default;
+
+    void Map(KeyTBase address, KeyTBase address_end, ValueT value) {
+        KeyT new_address = static_cast<KeyT>(address);
+        KeyT new_address_end = static_cast<KeyT>(address_end);
+        if (new_address < 0) {
+            new_address = 0;
+        }
+        if (new_address_end < 0) {
+            new_address_end = 0;
+        }
+        InternalMap(new_address, new_address_end, value);
+    }
+
+    void Unmap(KeyTBase address, KeyTBase address_end) {
+        Map(address, address_end, null_value);
+    }
+
+    [[nodiscard]] size_t GetContinousSizeFrom(KeyTBase address) const {
+        const KeyT new_address = static_cast<KeyT>(address);
+        if (new_address < 0) {
+            return 0;
+        }
+        return ContinousSizeInternal(new_address);
+    }
+
+    [[nodiscard]] ValueT GetValueAt(KeyT address) const {
+        const KeyT new_address = static_cast<KeyT>(address);
+        if (new_address < 0) {
+            return null_value;
+        }
+        return GetValueInternal(new_address);
+    }
+
+private:
+    using MapType = std::map<KeyT, ValueT>;
+    using IteratorType = typename MapType::iterator;
+    using ConstIteratorType = typename MapType::const_iterator;
+
+    size_t ContinousSizeInternal(KeyT address) const {
+        const auto it = GetFirstElementBeforeOrOn(address);
+        if (it == container.end() || it->second == null_value) {
+            return 0;
+        }
+        const auto it_end = std::next(it);
+        if (it_end == container.end()) {
+            return std::numeric_limits<KeyT>::max() - address;
+        }
+        return it_end->first - address;
+    }
+
+    ValueT GetValueInternal(KeyT address) const {
+        const auto it = GetFirstElementBeforeOrOn(address);
+        if (it == container.end()) {
+            return null_value;
+        }
+        return it->second;
+    }
+
+    ConstIteratorType GetFirstElementBeforeOrOn(KeyT address) const {
+        auto it = container.lower_bound(address);
+        if (it == container.begin()) {
+            return it;
+        }
+        if (it != container.end() && (it->first == address)) {
+            return it;
+        }
+        --it;
+        return it;
+    }
+
+    ValueT GetFirstValueWithin(KeyT address) {
+        auto it = container.lower_bound(address);
+        if (it == container.begin()) {
+            return it->second;
+        }
+        if (it == container.end()) [[unlikely]] { // this would be a bug
+            return null_value;
+        }
+        --it;
+        return it->second;
+    }
+
+    ValueT GetLastValueWithin(KeyT address) {
+        auto it = container.upper_bound(address);
+        if (it == container.end()) {
+            return null_value;
+        }
+        if (it == container.begin()) [[unlikely]] { // this would be a bug
+            return it->second;
+        }
+        --it;
+        return it->second;
+    }
+
+    void InternalMap(KeyT address, KeyT address_end, ValueT value) {
+        const bool must_add_start = GetFirstValueWithin(address) != value;
+        const ValueT last_value = GetLastValueWithin(address_end);
+        const bool must_add_end = last_value != value;
+        auto it = container.lower_bound(address);
+        const auto it_end = container.upper_bound(address_end);
+        while (it != it_end) {
+            it = container.erase(it);
+        }
+        if (must_add_start) {
+            container.emplace(address, value);
+        }
+        if (must_add_end) {
+            container.emplace(address_end, last_value);
+        }
+    }
+
+    ValueT null_value;
+    MapType container;
+};
+
+} // namespace Common
@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/make_unique_for_overwrite.h"
+
+namespace Common {
+
+/**
+ * ScratchBuffer class
+ * This class creates a default initialized heap allocated buffer for cases such as intermediate
+ * buffers being copied into entirely, where value initializing members during allocation or resize
+ * is redundant.
+ */
+template <typename T>
+class ScratchBuffer {
+public:
+    ScratchBuffer() = default;
+
+    explicit ScratchBuffer(size_t initial_capacity)
+        : last_requested_size{initial_capacity}, buffer_capacity{initial_capacity},
+          buffer{Common::make_unique_for_overwrite<T[]>(initial_capacity)} {}
+
+    ~ScratchBuffer() = default;
+
+    /// This will only grow the buffer's capacity if size is greater than the current capacity.
+    /// The previously held data will remain intact.
+    void resize(size_t size) {
+        if (size > buffer_capacity) {
+            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
+            std::move(buffer.get(), buffer.get() + buffer_capacity, new_buffer.get());
+            buffer = std::move(new_buffer);
+            buffer_capacity = size;
+        }
+        last_requested_size = size;
+    }
+
+    /// This will only grow the buffer's capacity if size is greater than the current capacity.
+    /// The previously held data will be destroyed if a reallocation occurs.
+    void resize_destructive(size_t size) {
+        if (size > buffer_capacity) {
+            buffer_capacity = size;
+            buffer = Common::make_unique_for_overwrite<T[]>(buffer_capacity);
+        }
+        last_requested_size = size;
+    }
+
+    [[nodiscard]] T* data() noexcept {
+        return buffer.get();
+    }
+
+    [[nodiscard]] const T* data() const noexcept {
+        return buffer.get();
+    }
+
+    [[nodiscard]] T* begin() noexcept {
+        return data();
+    }
+
+    [[nodiscard]] const T* begin() const noexcept {
+        return data();
+    }
+
+    [[nodiscard]] T* end() noexcept {
+        return data() + last_requested_size;
+    }
+
+    [[nodiscard]] const T* end() const noexcept {
+        return data() + last_requested_size;
+    }
+
+    [[nodiscard]] T& operator[](size_t i) {
+        return buffer[i];
+    }
+
+    [[nodiscard]] const T& operator[](size_t i) const {
+        return buffer[i];
+    }
+
+    [[nodiscard]] size_t size() const noexcept {
+        return last_requested_size;
+    }
+
+    [[nodiscard]] size_t capacity() const noexcept {
+        return buffer_capacity;
+    }
+
+private:
+    size_t last_requested_size{};
+    size_t buffer_capacity{};
+    std::unique_ptr<T[]> buffer{};
+};
+
+} // namespace Common
@@ -40,6 +40,7 @@ void LogSettings() {
    LOG_INFO(Config, "yuzu Configuration:");
    log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
    log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
+    log_setting("System_DeviceName", values.device_name.GetValue());
    log_setting("System_CurrentUser", values.current_user.GetValue());
    log_setting("System_LanguageIndex", values.language_index.GetValue());
    log_setting("System_RegionIndex", values.region_index.GetValue());
@@ -184,6 +185,7 @@ void RestoreGlobalState(bool is_powered_on) {
    // Renderer
    values.fsr_sharpening_slider.SetGlobal(true);
    values.renderer_backend.SetGlobal(true);
+    values.renderer_force_max_clock.SetGlobal(true);
    values.vulkan_device.SetGlobal(true);
    values.aspect_ratio.SetGlobal(true);
    values.max_anisotropy.SetGlobal(true);
@@ -199,6 +201,7 @@ void RestoreGlobalState(bool is_powered_on) {
    values.use_asynchronous_shaders.SetGlobal(true);
    values.use_fast_gpu_time.SetGlobal(true);
    values.use_pessimistic_flushes.SetGlobal(true);
+    values.use_vulkan_driver_pipeline_cache.SetGlobal(true);
    values.bg_red.SetGlobal(true);
    values.bg_green.SetGlobal(true);
    values.bg_blue.SetGlobal(true);
@@ -76,7 +76,8 @@ enum class ScalingFilter : u32 {
 enum class AntiAliasing : u32 {
    None = 0,
    Fxaa = 1,
-    LastAA = Fxaa,
+    Smaa = 2,
+    LastAA = Smaa,
 };

 struct ResolutionScalingInfo {
@@ -414,6 +415,7 @@ struct Values {
    // Renderer
    SwitchableSetting<RendererBackend, true> renderer_backend{
        RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
+    SwitchableSetting<bool> renderer_force_max_clock{true, "force_max_clock"};
    Setting<bool> renderer_debug{false, "debug"};
    Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
    Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
@@ -450,6 +452,8 @@ struct Values {
    SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
    SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
    SwitchableSetting<bool> use_pessimistic_flushes{false, "use_pessimistic_flushes"};
+    SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true,
+                                                             "use_vulkan_driver_pipeline_cache"};

    SwitchableSetting<u8> bg_red{0, "bg_red"};
    SwitchableSetting<u8> bg_green{0, "bg_green"};
@@ -457,6 +461,7 @@ struct Values {

    // System
    SwitchableSetting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    Setting<std::string> device_name{"Yuzu", "device_name"};
    // Measured in seconds since epoch
    std::optional<s64> custom_rtc;
    // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
@@ -529,6 +534,7 @@ struct Values {
    Setting<bool> reporting_services{false, "reporting_services"};
    Setting<bool> quest_flag{false, "quest_flag"};
    Setting<bool> disable_macro_jit{false, "disable_macro_jit"};
+    Setting<bool> disable_macro_hle{false, "disable_macro_hle"};
    Setting<bool> extended_logging{false, "extended_logging"};
    Setting<bool> use_debug_asserts{false, "use_debug_asserts"};
    Setting<bool> use_auto_stub{false, "use_auto_stub"};
@@ -11,6 +11,7 @@
 #include <mutex>
 #include <thread>
 #include "common/common_types.h"
+#include "common/polyfill_thread.h"

 namespace Common {

@@ -69,7 +70,7 @@ public:
    explicit Barrier(std::size_t count_) : count(count_) {}

    /// Blocks until all "count" threads have called Sync()
-    void Sync() {
+    bool Sync(std::stop_token token = {}) {
        std::unique_lock lk{mutex};
        const std::size_t current_generation = generation;

@@ -77,14 +78,16 @@ public:
            generation++;
            waiting = 0;
            condvar.notify_all();
+            return true;
        } else {
-            condvar.wait(lk,
-                         [this, current_generation] { return current_generation != generation; });
+            CondvarWait(condvar, lk, token,
+                        [this, current_generation] { return current_generation != generation; });
+            return !token.stop_requested();
        }
    }

 private:
-    std::condition_variable condvar;
+    std::condition_variable_any condvar;
    std::mutex mutex;
    std::size_t count;
    std::size_t waiting = 0;
@@ -201,6 +201,9 @@ add_library(core STATIC
    hle/kernel/k_event_info.h
    hle/kernel/k_handle_table.cpp
    hle/kernel/k_handle_table.h
+    hle/kernel/k_hardware_timer_base.h
+    hle/kernel/k_hardware_timer.cpp
+    hle/kernel/k_hardware_timer.h
    hle/kernel/k_interrupt_manager.cpp
    hle/kernel/k_interrupt_manager.h
    hle/kernel/k_light_condition_variable.cpp
@@ -268,6 +271,7 @@ add_library(core STATIC
    hle/kernel/k_thread_local_page.h
    hle/kernel/k_thread_queue.cpp
    hle/kernel/k_thread_queue.h
+    hle/kernel/k_timer_task.h
    hle/kernel/k_trace.h
    hle/kernel/k_transfer_memory.cpp
    hle/kernel/k_transfer_memory.h
@@ -290,8 +294,6 @@ add_library(core STATIC
    hle/kernel/svc_common.h
    hle/kernel/svc_types.h
    hle/kernel/svc_wrap.h
-    hle/kernel/time_manager.cpp
-    hle/kernel/time_manager.h
    hle/result.h
    hle/service/acc/acc.cpp
    hle/service/acc/acc.h
@@ -803,7 +805,7 @@ endif()
 create_target_directory_groups(core)

 target_link_libraries(core PUBLIC common PRIVATE audio_core network video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::opus)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json MbedTLS::mbedcrypto Opus::opus)
 if (MINGW)
    target_link_libraries(core PRIVATE ${MSWSOCK_LIBRARY})
 endif()
@@ -229,7 +229,11 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    config.enable_cycle_counting = true;

    // Code cache size
+#ifdef ARCHITECTURE_arm64
+    config.code_cache_size = 128_MiB;
+#else
    config.code_cache_size = 512_MiB;
+#endif

    // Allow memory fault handling to work
    if (system.DebuggerEnabled()) {
@@ -288,7 +288,11 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
    config.enable_cycle_counting = true;

    // Code cache size
+#ifdef ARCHITECTURE_arm64
+    config.code_cache_size = 128_MiB;
+#else
    config.code_cache_size = 512_MiB;
+#endif

    // Allow memory fault handling to work
    if (system.DebuggerEnabled()) {
@@ -183,26 +183,20 @@ struct System::Impl {
        Initialize(system);
    }

-    SystemResultStatus Run() {
+    void Run() {
        std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;

        kernel.Suspend(false);
        core_timing.SyncPause(false);
        is_paused.store(false, std::memory_order_relaxed);
-
-        return status;
    }

-    SystemResultStatus Pause() {
+    void Pause() {
        std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;

        core_timing.SyncPause(true);
        kernel.Suspend(true);
        is_paused.store(true, std::memory_order_relaxed);
-
-        return status;
    }

    bool IsPaused() const {
@@ -389,7 +383,9 @@ struct System::Impl {
        kernel.ShutdownCores();
        cpu_manager.Shutdown();
        debugger.reset();
-        services->KillNVNFlinger();
+        if (services) {
+            services->KillNVNFlinger();
+        }
        kernel.CloseServices();
        services.reset();
        service_manager.reset();
@@ -551,12 +547,12 @@ void System::Initialize() {
    impl->Initialize(*this);
 }

-SystemResultStatus System::Run() {
-    return impl->Run();
+void System::Run() {
+    impl->Run();
 }

-SystemResultStatus System::Pause() {
-    return impl->Pause();
+void System::Pause() {
+    impl->Pause();
 }

 bool System::IsPaused() const {
@@ -152,13 +152,13 @@ public:
     * Run the OS and Application
     * This function will start emulation and run the relevant devices
     */
-    [[nodiscard]] SystemResultStatus Run();
+    void Run();

    /**
     * Pause the OS and Application
     * This function will pause emulation and stop the relevant devices
     */
-    [[nodiscard]] SystemResultStatus Pause();
+    void Pause();

    /// Check if the core is currently paused.
    [[nodiscard]] bool IsPaused() const;
@@ -20,23 +20,20 @@ namespace Core {
 CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;

-void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
-                             std::size_t core) {
-    cpu_manager.RunThread(core);
-}
-
 void CpuManager::Initialize() {
    num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
    gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);

    for (std::size_t core = 0; core < num_cores; core++) {
-        core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+        core_data[core].host_thread =
+            std::jthread([this, core](std::stop_token token) { RunThread(token, core); });
    }
 }

 void CpuManager::Shutdown() {
    for (std::size_t core = 0; core < num_cores; core++) {
        if (core_data[core].host_thread.joinable()) {
+            core_data[core].host_thread.request_stop();
            core_data[core].host_thread.join();
        }
    }
@@ -184,7 +181,7 @@ void CpuManager::ShutdownThread() {
    UNREACHABLE();
 }

-void CpuManager::RunThread(std::size_t core) {
+void CpuManager::RunThread(std::stop_token token, std::size_t core) {
    /// Initialization
    system.RegisterCoreThread(core);
    std::string name;
@@ -206,7 +203,9 @@ void CpuManager::RunThread(std::size_t core) {
    });

    // Running
-    gpu_barrier->Sync();
+    if (!gpu_barrier->Sync(token)) {
+        return;
+    }

    if (!is_async_gpu && !is_multicore) {
        system.GPU().ObtainContext();
@@ -81,12 +81,10 @@ private:
    void SingleCoreRunGuestThread();
    void SingleCoreRunIdleThread();

-    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
-
    void GuestActivate();
    void HandleInterrupt();
    void ShutdownThread();
-    void RunThread(std::size_t core);
+    void RunThread(std::stop_token stop_token, std::size_t core);

    struct CoreData {
        std::shared_ptr<Common::Fiber> host_context;
@@ -194,9 +194,9 @@ std::size_t VfsFile::WriteBytes(const std::vector<u8>& data, std::size_t offset)

 std::string VfsFile::GetFullPath() const {
    if (GetContainingDirectory() == nullptr)
-        return "/" + GetName();
+        return '/' + GetName();

-    return GetContainingDirectory()->GetFullPath() + "/" + GetName();
+    return GetContainingDirectory()->GetFullPath() + '/' + GetName();
 }

 VirtualFile VfsDirectory::GetFileRelative(std::string_view path) const {
@@ -435,7 +435,7 @@ std::string VfsDirectory::GetFullPath() const {
    if (IsRoot())
        return GetName();

-    return GetParentDirectory()->GetFullPath() + "/" + GetName();
+    return GetParentDirectory()->GetFullPath() + '/' + GetName();
 }

 bool ReadOnlyVfsDirectory::IsWritable() const {
@@ -131,6 +131,10 @@ public:
        return active_config;
    }

+    bool StrictContextRequired() const {
+        return strict_context_required;
+    }
+
    /**
     * Requests the internal configuration to be replaced by the specified argument at some point in
     * the future.
@@ -207,6 +211,8 @@ protected:

    WindowSystemInfo window_info;

+    bool strict_context_required = false;
+
 private:
    /**
     * Handler called when the minimal client area was requested to be changed via SetConfig.
@@ -40,6 +40,11 @@ void EmulatedConsole::SetTouchParams() {
        touch_params[index++] = std::move(touchscreen_param);
    }

+    if (Settings::values.touch_from_button_maps.empty()) {
+        LOG_WARNING(Input, "touch_from_button_maps is unset by frontend config");
+        return;
+    }
+
    const auto button_index =
        static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
    const auto& touch_buttons = Settings::values.touch_from_button_maps[button_index].buttons;
@@ -11,6 +11,11 @@
 namespace Core::HID {
 constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
 constexpr s32 HID_TRIGGER_MAX = 0x7fff;
+// Use a common UUID for TAS and Virtual Gamepad
+constexpr Common::UUID TAS_UUID =
+    Common::UUID{{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
+constexpr Common::UUID VIRTUAL_UUID =
+    Common::UUID{{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};

 EmulatedController::EmulatedController(NpadIdType npad_id_type_) : npad_id_type(npad_id_type_) {}

@@ -145,6 +150,7 @@ void EmulatedController::LoadDevices() {
    output_params[3].Set("output", true);

    LoadTASParams();
+    LoadVirtualGamepadParams();

    std::ranges::transform(button_params, button_devices.begin(), Common::Input::CreateInputDevice);
    std::ranges::transform(stick_params, stick_devices.begin(), Common::Input::CreateInputDevice);
@@ -163,6 +169,12 @@ void EmulatedController::LoadDevices() {
                           Common::Input::CreateInputDevice);
    std::ranges::transform(tas_stick_params, tas_stick_devices.begin(),
                           Common::Input::CreateInputDevice);
+
+    // Initialize virtual gamepad devices
+    std::ranges::transform(virtual_button_params, virtual_button_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(virtual_stick_params, virtual_stick_devices.begin(),
+                           Common::Input::CreateInputDevice);
 }

 void EmulatedController::LoadTASParams() {
@@ -203,6 +215,53 @@ void EmulatedController::LoadTASParams() {
    tas_stick_params[Settings::NativeAnalog::LStick].Set("axis_y", 1);
    tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_x", 2);
    tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
+
+    // set to optimal stick to avoid sanitizing the stick and tweaking the coordinates
+    // making sure they play back in the game as originally written down in the script file
+    tas_stick_params[Settings::NativeAnalog::LStick].Set("deadzone", 0.0f);
+    tas_stick_params[Settings::NativeAnalog::LStick].Set("range", 1.0f);
+    tas_stick_params[Settings::NativeAnalog::RStick].Set("deadzone", 0.0f);
+    tas_stick_params[Settings::NativeAnalog::RStick].Set("range", 1.0f);
+}
+
+void EmulatedController::LoadVirtualGamepadParams() {
+    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    Common::ParamPackage common_params{};
+    common_params.Set("engine", "virtual_gamepad");
+    common_params.Set("port", static_cast<int>(player_index));
+    for (auto& param : virtual_button_params) {
+        param = common_params;
+    }
+    for (auto& param : virtual_stick_params) {
+        param = common_params;
+    }
+
+    // TODO(german77): Replace this with an input profile or something better
+    virtual_button_params[Settings::NativeButton::A].Set("button", 0);
+    virtual_button_params[Settings::NativeButton::B].Set("button", 1);
+    virtual_button_params[Settings::NativeButton::X].Set("button", 2);
+    virtual_button_params[Settings::NativeButton::Y].Set("button", 3);
+    virtual_button_params[Settings::NativeButton::LStick].Set("button", 4);
+    virtual_button_params[Settings::NativeButton::RStick].Set("button", 5);
+    virtual_button_params[Settings::NativeButton::L].Set("button", 6);
+    virtual_button_params[Settings::NativeButton::R].Set("button", 7);
+    virtual_button_params[Settings::NativeButton::ZL].Set("button", 8);
+    virtual_button_params[Settings::NativeButton::ZR].Set("button", 9);
+    virtual_button_params[Settings::NativeButton::Plus].Set("button", 10);
+    virtual_button_params[Settings::NativeButton::Minus].Set("button", 11);
+    virtual_button_params[Settings::NativeButton::DLeft].Set("button", 12);
+    virtual_button_params[Settings::NativeButton::DUp].Set("button", 13);
+    virtual_button_params[Settings::NativeButton::DRight].Set("button", 14);
+    virtual_button_params[Settings::NativeButton::DDown].Set("button", 15);
+    virtual_button_params[Settings::NativeButton::SL].Set("button", 16);
+    virtual_button_params[Settings::NativeButton::SR].Set("button", 17);
+    virtual_button_params[Settings::NativeButton::Home].Set("button", 18);
+    virtual_button_params[Settings::NativeButton::Screenshot].Set("button", 19);
+
+    virtual_stick_params[Settings::NativeAnalog::LStick].Set("axis_x", 0);
+    virtual_stick_params[Settings::NativeAnalog::LStick].Set("axis_y", 1);
+    virtual_stick_params[Settings::NativeAnalog::RStick].Set("axis_x", 2);
+    virtual_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
 }

 void EmulatedController::ReloadInput() {
@@ -294,10 +353,6 @@ void EmulatedController::ReloadInput() {
        }
    }

-    // Use a common UUID for TAS
-    static constexpr Common::UUID TAS_UUID = Common::UUID{
-        {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
-
    // Register TAS devices. No need to force update
    for (std::size_t index = 0; index < tas_button_devices.size(); ++index) {
        if (!tas_button_devices[index]) {
@@ -322,6 +377,31 @@ void EmulatedController::ReloadInput() {
                },
        });
    }
+
+    // Register virtual devices. No need to force update
+    for (std::size_t index = 0; index < virtual_button_devices.size(); ++index) {
+        if (!virtual_button_devices[index]) {
+            continue;
+        }
+        virtual_button_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, VIRTUAL_UUID);
+                },
+        });
+    }
+
+    for (std::size_t index = 0; index < virtual_stick_devices.size(); ++index) {
+        if (!virtual_stick_devices[index]) {
+            continue;
+        }
+        virtual_stick_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, VIRTUAL_UUID);
+                },
+        });
+    }
 }

 void EmulatedController::UnloadInput() {
@@ -349,6 +429,12 @@ void EmulatedController::UnloadInput() {
    for (auto& stick : tas_stick_devices) {
        stick.reset();
    }
+    for (auto& button : virtual_button_devices) {
+        button.reset();
+    }
+    for (auto& stick : virtual_stick_devices) {
+        stick.reset();
+    }
    camera_devices.reset();
    nfc_devices.reset();
 }
@@ -691,7 +777,12 @@ void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback,

    // Only read stick values that have the same uuid or are over the threshold to avoid flapping
    if (controller.stick_values[index].uuid != uuid) {
-        if (!stick_value.down && !stick_value.up && !stick_value.left && !stick_value.right) {
+        const bool is_tas = uuid == TAS_UUID;
+        if (is_tas && stick_value.x.value == 0 && stick_value.y.value == 0) {
+            return;
+        }
+        if (!is_tas && !stick_value.down && !stick_value.up && !stick_value.left &&
+            !stick_value.right) {
            return;
        }
    }
@@ -385,6 +385,9 @@ private:
    /// Set the params for TAS devices
    void LoadTASParams();

+    /// Set the params for virtual pad devices
+    void LoadVirtualGamepadParams();
+
    /**
     * @param use_temporary_value If true tmp_npad_type will be used
     * @return true if the controller style is fullkey
@@ -500,6 +503,12 @@ private:
    ButtonDevices tas_button_devices;
    StickDevices tas_stick_devices;

+    // Virtual gamepad related variables
+    ButtonParams virtual_button_params;
+    StickParams virtual_stick_params;
+    ButtonDevices virtual_button_devices;
+    StickDevices virtual_stick_devices;
+
    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
    std::unordered_map<int, ControllerUpdateCallback> callback_list;
@@ -167,6 +167,9 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
        }
        if (incoming) {
            // Populate the object lists with the data in the IPC request.
+            incoming_copy_handles.reserve(handle_descriptor_header->num_handles_to_copy);
+            incoming_move_handles.reserve(handle_descriptor_header->num_handles_to_move);
+
            for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
                incoming_copy_handles.push_back(rp.Pop<Handle>());
            }
@@ -181,6 +184,11 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
        }
    }

+    buffer_x_desciptors.reserve(command_header->num_buf_x_descriptors);
+    buffer_a_desciptors.reserve(command_header->num_buf_a_descriptors);
+    buffer_b_desciptors.reserve(command_header->num_buf_b_descriptors);
+    buffer_w_desciptors.reserve(command_header->num_buf_w_descriptors);
+
    for (u32 i = 0; i < command_header->num_buf_x_descriptors; ++i) {
        buffer_x_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorX>());
    }
@@ -318,25 +326,23 @@ Result HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_threa
 }

 std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
-    std::vector<u8> buffer{};
    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                           BufferDescriptorA()[buffer_index].Size()};
-
    if (is_buffer_a) {
        ASSERT_OR_EXECUTE_MSG(
-            BufferDescriptorA().size() > buffer_index, { return buffer; },
+            BufferDescriptorA().size() > buffer_index, { return {}; },
            "BufferDescriptorA invalid buffer_index {}", buffer_index);
-        buffer.resize(BufferDescriptorA()[buffer_index].Size());
+        std::vector<u8> buffer(BufferDescriptorA()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorA()[buffer_index].Address(), buffer.data(), buffer.size());
+        return buffer;
    } else {
        ASSERT_OR_EXECUTE_MSG(
-            BufferDescriptorX().size() > buffer_index, { return buffer; },
+            BufferDescriptorX().size() > buffer_index, { return {}; },
            "BufferDescriptorX invalid buffer_index {}", buffer_index);
-        buffer.resize(BufferDescriptorX()[buffer_index].Size());
+        std::vector<u8> buffer(BufferDescriptorX()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorX()[buffer_index].Address(), buffer.data(), buffer.size());
+        return buffer;
    }
-
-    return buffer;
 }

 std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
@@ -10,7 +10,6 @@
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
-#include "core/hle/kernel/time_manager.h"
 #include "core/memory.h"

 namespace Kernel {
@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/k_hardware_timer.h"
+#include "core/hle/kernel/k_scheduler.h"
+
+namespace Kernel {
+
+void KHardwareTimer::Initialize() {
+    // Create the timing callback to register with CoreTiming.
+    m_event_type = Core::Timing::CreateEvent(
+        "KHardwareTimer::Callback", [](std::uintptr_t timer_handle, s64, std::chrono::nanoseconds) {
+            reinterpret_cast<KHardwareTimer*>(timer_handle)->DoTask();
+            return std::nullopt;
+        });
+}
+
+void KHardwareTimer::Finalize() {
+    this->DisableInterrupt();
+    m_event_type.reset();
+}
+
+void KHardwareTimer::DoTask() {
+    // Handle the interrupt.
+    {
+        KScopedSchedulerLock slk{m_kernel};
+        KScopedSpinLock lk(this->GetLock());
+
+        //! Ignore this event if needed.
+        if (!this->GetInterruptEnabled()) {
+            return;
+        }
+
+        // Disable the timer interrupt while we handle this.
+        this->DisableInterrupt();
+
+        if (const s64 next_time = this->DoInterruptTaskImpl(GetTick());
+            0 < next_time && next_time <= m_wakeup_time) {
+            // We have a next time, so we should set the time to interrupt and turn the interrupt
+            // on.
+            this->EnableInterrupt(next_time);
+        }
+    }
+
+    // Clear the timer interrupt.
+    // Kernel::GetInterruptManager().ClearInterrupt(KInterruptName_NonSecurePhysicalTimer,
+    //                                              GetCurrentCoreId());
+}
+
+void KHardwareTimer::EnableInterrupt(s64 wakeup_time) {
+    this->DisableInterrupt();
+
+    m_wakeup_time = wakeup_time;
+    m_kernel.System().CoreTiming().ScheduleEvent(std::chrono::nanoseconds{m_wakeup_time},
+                                                 m_event_type, reinterpret_cast<uintptr_t>(this),
+                                                 true);
+}
+
+void KHardwareTimer::DisableInterrupt() {
+    m_kernel.System().CoreTiming().UnscheduleEvent(m_event_type, reinterpret_cast<uintptr_t>(this));
+    m_wakeup_time = std::numeric_limits<s64>::max();
+}
+
+s64 KHardwareTimer::GetTick() const {
+    return m_kernel.System().CoreTiming().GetGlobalTimeNs().count();
+}
+
+bool KHardwareTimer::GetInterruptEnabled() {
+    return m_wakeup_time != std::numeric_limits<s64>::max();
+}
+
+} // namespace Kernel
@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/kernel/k_hardware_timer_base.h"
+
+namespace Core::Timing {
+struct EventType;
+} // namespace Core::Timing
+
+namespace Kernel {
+
+class KHardwareTimer : /* public KInterruptTask, */ public KHardwareTimerBase {
+public:
+    explicit KHardwareTimer(KernelCore& kernel) : KHardwareTimerBase{kernel} {}
+
+    // Public API.
+    void Initialize();
+    void Finalize();
+
+    s64 GetCount() const {
+        return GetTick();
+    }
+
+    void RegisterTask(KTimerTask* task, s64 time_from_now) {
+        this->RegisterAbsoluteTask(task, GetTick() + time_from_now);
+    }
+
+    void RegisterAbsoluteTask(KTimerTask* task, s64 task_time) {
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk{this->GetLock()};
+
+        if (this->RegisterAbsoluteTaskImpl(task, task_time)) {
+            if (task_time <= m_wakeup_time) {
+                this->EnableInterrupt(task_time);
+            }
+        }
+    }
+
+private:
+    void EnableInterrupt(s64 wakeup_time);
+    void DisableInterrupt();
+    bool GetInterruptEnabled();
+    s64 GetTick() const;
+    void DoTask();
+
+private:
+    // Absolute time in nanoseconds
+    s64 m_wakeup_time{std::numeric_limits<s64>::max()};
+    std::shared_ptr<Core::Timing::EventType> m_event_type{};
+};
+
+} // namespace Kernel
@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/kernel/k_spin_lock.h"
+#include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/k_timer_task.h"
+
+namespace Kernel {
+
+class KHardwareTimerBase {
+public:
+    explicit KHardwareTimerBase(KernelCore& kernel) : m_kernel{kernel} {}
+
+    void CancelTask(KTimerTask* task) {
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk{m_lock};
+
+        if (const s64 task_time = task->GetTime(); task_time > 0) {
+            this->RemoveTaskFromTree(task);
+        }
+    }
+
+protected:
+    KSpinLock& GetLock() {
+        return m_lock;
+    }
+
+    s64 DoInterruptTaskImpl(s64 cur_time) {
+        // We want to handle all tasks, returning the next time that a task is scheduled.
+        while (true) {
+            // Get the next task. If there isn't one, return 0.
+            KTimerTask* task = m_next_task;
+            if (task == nullptr) {
+                return 0;
+            }
+
+            // If the task needs to be done in the future, do it in the future and not now.
+            if (const s64 task_time = task->GetTime(); task_time > cur_time) {
+                return task_time;
+            }
+
+            // Remove the task from the tree of tasks, and update our next task.
+            this->RemoveTaskFromTree(task);
+
+            // Handle the task.
+            task->OnTimer();
+        }
+    }
+
+    bool RegisterAbsoluteTaskImpl(KTimerTask* task, s64 task_time) {
+        ASSERT(task_time > 0);
+
+        // Set the task's time, and insert it into our tree.
+        task->SetTime(task_time);
+        m_task_tree.insert(*task);
+
+        // Update our next task if relevant.
+        if (m_next_task != nullptr && m_next_task->GetTime() <= task_time) {
+            return false;
+        }
+        m_next_task = task;
+        return true;
+    }
+
+private:
+    void RemoveTaskFromTree(KTimerTask* task) {
+        // Erase from the tree.
+        auto it = m_task_tree.erase(m_task_tree.iterator_to(*task));
+
+        // Clear the task's scheduled time.
+        task->SetTime(0);
+
+        // Update our next task if relevant.
+        if (m_next_task == task) {
+            m_next_task = (it != m_task_tree.end()) ? std::addressof(*it) : nullptr;
+        }
+    }
+
+protected:
+    KernelCore& m_kernel;
+
+private:
+    using TimerTaskTree = Common::IntrusiveRedBlackTreeBaseTraits<KTimerTask>::TreeType<KTimerTask>;
+
+    KSpinLock m_lock{};
+    TimerTaskTree m_task_tree{};
+    KTimerTask* m_next_task{};
+};
+
+} // namespace Kernel
@@ -285,6 +285,17 @@ void KProcess::UnregisterThread(KThread* thread) {
    thread_list.remove(thread);
 }

+u64 KProcess::GetFreeThreadCount() const {
+    if (resource_limit != nullptr) {
+        const auto current_value =
+            resource_limit->GetCurrentValue(LimitableResource::ThreadCountMax);
+        const auto limit_value = resource_limit->GetLimitValue(LimitableResource::ThreadCountMax);
+        return limit_value - current_value;
+    } else {
+        return 0;
+    }
+}
+
 Result KProcess::Reset() {
    // Lock the process and the scheduler.
    KScopedLightLock lk(state_lock);
@@ -304,6 +304,9 @@ public:
    /// from this process' thread list.
    void UnregisterThread(KThread* thread);

+    /// Retrieves the number of available threads for this process.
+    u64 GetFreeThreadCount() const;
+
    /// Clears the signaled state of the process if and only if it's signaled.
    ///
    /// @pre The process must not be already terminated. If this is called on a
@@ -5,9 +5,9 @@

 #include "common/common_types.h"
 #include "core/hle/kernel/global_scheduler_context.h"
+#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/time_manager.h"

 namespace Kernel {

@@ -22,7 +22,7 @@ public:
    ~KScopedSchedulerLockAndSleep() {
        // Register the sleep.
        if (timeout_tick > 0) {
-            kernel.TimeManager().ScheduleTimeEvent(thread, timeout_tick);
+            kernel.HardwareTimer().RegisterTask(thread, timeout_tick);
        }

        // Unlock the scheduler.
@@ -6,6 +6,7 @@
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_shared_memory.h"
+#include "core/hle/kernel/k_system_resource.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"

@@ -18,19 +19,19 @@ KSharedMemory::~KSharedMemory() {
 }

 Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                                 KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
-                                 Svc::MemoryPermission user_permission_, PAddr physical_address_,
-                                 std::size_t size_, std::string name_) {
+                                 Svc::MemoryPermission owner_permission_,
+                                 Svc::MemoryPermission user_permission_, std::size_t size_,
+                                 std::string name_) {
    // Set members.
    owner_process = owner_process_;
    device_memory = &device_memory_;
-    page_list = std::move(page_list_);
    owner_permission = owner_permission_;
    user_permission = user_permission_;
-    physical_address = physical_address_;
-    size = size_;
+    size = Common::AlignUp(size_, PageSize);
    name = std::move(name_);

+    const size_t num_pages = Common::DivideUp(size, PageSize);
+
    // Get the resource limit.
    KResourceLimit* reslimit = kernel.GetSystemResourceLimit();

@@ -39,6 +40,17 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
                                                  size_);
    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

+    // Allocate the memory.
+
+    //! HACK: Open continuous mapping from sysmodule pool.
+    auto option = KMemoryManager::EncodeOption(KMemoryManager::Pool::Secure,
+                                               KMemoryManager::Direction::FromBack);
+    physical_address = kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, option);
+    R_UNLESS(physical_address != 0, ResultOutOfMemory);
+
+    //! Insert the result into our page group.
+    page_group.emplace(physical_address, num_pages);
+
    // Commit our reservation.
    memory_reservation.Commit();

@@ -50,12 +62,23 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
    is_initialized = true;

    // Clear all pages in the memory.
-    std::memset(device_memory_.GetPointer<void>(physical_address_), 0, size_);
+    for (const auto& block : page_group->Nodes()) {
+        std::memset(device_memory_.GetPointer<void>(block.GetAddress()), 0, block.GetSize());
+    }

    return ResultSuccess;
 }

 void KSharedMemory::Finalize() {
+    // Close and finalize the page group.
+    // page_group->Close();
+    // page_group->Finalize();
+
+    //! HACK: Manually close.
+    for (const auto& block : page_group->Nodes()) {
+        kernel.MemoryManager().Close(block.GetAddress(), block.GetNumPages());
+    }
+
    // Release the memory reservation.
    resource_limit->Release(LimitableResource::PhysicalMemoryMax, size);
    resource_limit->Close();
@@ -65,32 +88,28 @@ void KSharedMemory::Finalize() {
 }

 Result KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t map_size,
-                          Svc::MemoryPermission permissions) {
-    const u64 page_count{(map_size + PageSize - 1) / PageSize};
+                          Svc::MemoryPermission map_perm) {
+    // Validate the size.
+    R_UNLESS(size == map_size, ResultInvalidSize);

-    if (page_list.GetNumPages() != page_count) {
-        UNIMPLEMENTED_MSG("Page count does not match");
-    }
-
-    const Svc::MemoryPermission expected =
+    // Validate the permission.
+    const Svc::MemoryPermission test_perm =
        &target_process == owner_process ? owner_permission : user_permission;
-
-    if (permissions != expected) {
-        UNIMPLEMENTED_MSG("Permission does not match");
+    if (test_perm == Svc::MemoryPermission::DontCare) {
+        ASSERT(map_perm == Svc::MemoryPermission::Read || map_perm == Svc::MemoryPermission::Write);
+    } else {
+        R_UNLESS(map_perm == test_perm, ResultInvalidNewMemoryPermission);
    }

-    return target_process.PageTable().MapPages(address, page_list, KMemoryState::Shared,
-                                               ConvertToKMemoryPermission(permissions));
+    return target_process.PageTable().MapPages(address, *page_group, KMemoryState::Shared,
+                                               ConvertToKMemoryPermission(map_perm));
 }

 Result KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {
-    const u64 page_count{(unmap_size + PageSize - 1) / PageSize};
+    // Validate the size.
+    R_UNLESS(size == unmap_size, ResultInvalidSize);

-    if (page_list.GetNumPages() != page_count) {
-        UNIMPLEMENTED_MSG("Page count does not match");
-    }
-
-    return target_process.PageTable().UnmapPages(address, page_list, KMemoryState::Shared);
+    return target_process.PageTable().UnmapPages(address, *page_group, KMemoryState::Shared);
 }

 } // namespace Kernel
@@ -3,6 +3,7 @@

 #pragma once

+#include <optional>
 #include <string>

 #include "common/common_types.h"
@@ -26,9 +27,8 @@ public:
    ~KSharedMemory() override;

    Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                      KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
-                      Svc::MemoryPermission user_permission_, PAddr physical_address_,
-                      std::size_t size_, std::string name_);
+                      Svc::MemoryPermission owner_permission_,
+                      Svc::MemoryPermission user_permission_, std::size_t size_, std::string name_);

    /**
     * Maps a shared memory block to an address in the target process' address space
@@ -76,7 +76,7 @@ public:
 private:
    Core::DeviceMemory* device_memory{};
    KProcess* owner_process{};
-    KPageGroup page_list;
+    std::optional<KPageGroup> page_group{};
    Svc::MemoryPermission owner_permission{};
    Svc::MemoryPermission user_permission{};
    PAddr physical_address{};
@@ -22,6 +22,7 @@
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_spin_lock.h"
 #include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/kernel/k_timer_task.h"
 #include "core/hle/kernel/k_worker_task.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_common.h"
@@ -112,7 +113,8 @@ void SetCurrentThread(KernelCore& kernel, KThread* thread);
 [[nodiscard]] s32 GetCurrentCoreId(KernelCore& kernel);

 class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KWorkerTask>,
-                      public boost::intrusive::list_base_hook<> {
+                      public boost::intrusive::list_base_hook<>,
+                      public KTimerTask {
    KERNEL_AUTOOBJECT_TRAITS(KThread, KSynchronizationObject);

 private:
@@ -840,4 +842,8 @@ private:
    KernelCore& kernel;
 };

+inline void KTimerTask::OnTimer() {
+    static_cast<KThread*>(this)->OnTimer();
+}
+
 } // namespace Kernel
@@ -1,9 +1,9 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/time_manager.h"

 namespace Kernel {

@@ -22,7 +22,7 @@ void KThreadQueue::EndWait(KThread* waiting_thread, Result wait_result) {
    waiting_thread->ClearWaitQueue();

    // Cancel the thread task.
-    kernel.TimeManager().UnscheduleTimeEvent(waiting_thread);
+    kernel.HardwareTimer().CancelTask(waiting_thread);
 }

 void KThreadQueue::CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) {
@@ -37,7 +37,7 @@ void KThreadQueue::CancelWait(KThread* waiting_thread, Result wait_result, bool

    // Cancel the thread task.
    if (cancel_timer_task) {
-        kernel.TimeManager().UnscheduleTimeEvent(waiting_thread);
+        kernel.HardwareTimer().CancelTask(waiting_thread);
    }
 }

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/intrusive_red_black_tree.h"
+
+namespace Kernel {
+
+class KTimerTask : public Common::IntrusiveRedBlackTreeBaseNode<KTimerTask> {
+public:
+    static constexpr int Compare(const KTimerTask& lhs, const KTimerTask& rhs) {
+        if (lhs.GetTime() < rhs.GetTime()) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+
+    constexpr explicit KTimerTask() = default;
+
+    constexpr void SetTime(s64 t) {
+        m_time = t;
+    }
+
+    constexpr s64 GetTime() const {
+        return m_time;
+    }
+
+    // NOTE: This is virtual in Nintendo's kernel. Prior to 13.0.0, KWaitObject was also a
+    // TimerTask; this is no longer the case. Since this is now KThread exclusive, we have
+    // devirtualized (see inline declaration for this inside k_thread.h).
+    void OnTimer();
+
+private:
+    // Absolute time in nanoseconds
+    s64 m_time{};
+};
+
+} // namespace Kernel
@@ -26,6 +26,7 @@
 #include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_dynamic_resource_manager.h"
 #include "core/hle/kernel/k_handle_table.h"
+#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_page_buffer.h"
@@ -39,7 +40,6 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/service_thread.h"
-#include "core/hle/kernel/time_manager.h"
 #include "core/hle/result.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/memory.h"
@@ -55,7 +55,7 @@ struct KernelCore::Impl {
    static constexpr size_t ReservedDynamicPageCount = 64;

    explicit Impl(Core::System& system_, KernelCore& kernel_)
-        : time_manager{system_}, service_threads_manager{1, "ServiceThreadsManager"},
+        : service_threads_manager{1, "ServiceThreadsManager"},
          service_thread_barrier{2}, system{system_} {}

    void SetMulticore(bool is_multi) {
@@ -63,6 +63,9 @@ struct KernelCore::Impl {
    }

    void Initialize(KernelCore& kernel) {
+        hardware_timer = std::make_unique<Kernel::KHardwareTimer>(kernel);
+        hardware_timer->Initialize();
+
        global_object_list_container = std::make_unique<KAutoObjectWithListContainer>(kernel);
        global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel);
        global_handle_table = std::make_unique<Kernel::KHandleTable>(kernel);
@@ -91,6 +94,7 @@ struct KernelCore::Impl {
                                       pt_heap_region.GetSize());
        }

+        InitializeHackSharedMemory();
        RegisterHostThread(nullptr);

        default_service_thread = &CreateServiceThread(kernel, "DefaultServiceThread");
@@ -104,12 +108,16 @@ struct KernelCore::Impl {
    }

    void CloseCurrentProcess() {
-        (*current_process).Finalize();
-        // current_process->Close();
-        // TODO: The current process should be destroyed based on accurate ref counting after
+        KProcess* old_process = current_process.exchange(nullptr);
+        if (old_process == nullptr) {
+            return;
+        }
+
+        // old_process->Close();
+        // TODO: The process should be destroyed based on accurate ref counting after
        // calling Close(). Adding a manual Destroy() call instead to avoid a memory leak.
-        (*current_process).Destroy();
-        current_process = nullptr;
+        old_process->Finalize();
+        old_process->Destroy();
    }

    void Shutdown() {
@@ -189,6 +197,9 @@ struct KernelCore::Impl {
        // Ensure that the object list container is finalized and properly shutdown.
        global_object_list_container->Finalize();
        global_object_list_container.reset();
+
+        hardware_timer->Finalize();
+        hardware_timer.reset();
    }

    void CloseServices() {
@@ -716,14 +727,14 @@ struct KernelCore::Impl {
    }

    void InitializeMemoryLayout() {
-        const auto system_pool = memory_layout->GetKernelSystemPoolRegionPhysicalExtents();
-
        // Initialize the memory manager.
        memory_manager = std::make_unique<KMemoryManager>(system);
        const auto& management_region = memory_layout->GetPoolManagementRegion();
        ASSERT(management_region.GetEndAddress() != 0);
        memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize());
+    }

+    void InitializeHackSharedMemory() {
        // Setup memory regions for emulated processes
        // TODO(bunnei): These should not be hardcoded regions initialized within the kernel
        constexpr std::size_t hid_size{0x40000};
@@ -732,39 +743,23 @@ struct KernelCore::Impl {
        constexpr std::size_t time_size{0x1000};
        constexpr std::size_t hidbus_size{0x1000};

-        const PAddr hid_phys_addr{system_pool.GetAddress()};
-        const PAddr font_phys_addr{system_pool.GetAddress() + hid_size};
-        const PAddr irs_phys_addr{system_pool.GetAddress() + hid_size + font_size};
-        const PAddr time_phys_addr{system_pool.GetAddress() + hid_size + font_size + irs_size};
-        const PAddr hidbus_phys_addr{system_pool.GetAddress() + hid_size + font_size + irs_size +
-                                     time_size};
-
        hid_shared_mem = KSharedMemory::Create(system.Kernel());
        font_shared_mem = KSharedMemory::Create(system.Kernel());
        irs_shared_mem = KSharedMemory::Create(system.Kernel());
        time_shared_mem = KSharedMemory::Create(system.Kernel());
        hidbus_shared_mem = KSharedMemory::Create(system.Kernel());

-        hid_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                   {hid_phys_addr, hid_size / PageSize},
-                                   Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                   hid_phys_addr, hid_size, "HID:SharedMemory");
-        font_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                    {font_phys_addr, font_size / PageSize},
-                                    Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                    font_phys_addr, font_size, "Font:SharedMemory");
-        irs_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                   {irs_phys_addr, irs_size / PageSize},
-                                   Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                   irs_phys_addr, irs_size, "IRS:SharedMemory");
-        time_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                    {time_phys_addr, time_size / PageSize},
-                                    Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                    time_phys_addr, time_size, "Time:SharedMemory");
-        hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr,
-                                      {hidbus_phys_addr, hidbus_size / PageSize},
-                                      Svc::MemoryPermission::None, Svc::MemoryPermission::Read,
-                                      hidbus_phys_addr, hidbus_size, "HidBus:SharedMemory");
+        hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                   Svc::MemoryPermission::Read, hid_size, "HID:SharedMemory");
+        font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                    Svc::MemoryPermission::Read, font_size, "Font:SharedMemory");
+        irs_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                   Svc::MemoryPermission::Read, irs_size, "IRS:SharedMemory");
+        time_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                    Svc::MemoryPermission::Read, time_size, "Time:SharedMemory");
+        hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
+                                      Svc::MemoryPermission::Read, hidbus_size,
+                                      "HidBus:SharedMemory");
    }

    KClientPort* CreateNamedServicePort(std::string name) {
@@ -828,7 +823,7 @@ struct KernelCore::Impl {
    std::vector<KProcess*> process_list;
    std::atomic<KProcess*> current_process{};
    std::unique_ptr<Kernel::GlobalSchedulerContext> global_scheduler_context;
-    Kernel::TimeManager time_manager;
+    std::unique_ptr<Kernel::KHardwareTimer> hardware_timer;

    Init::KSlabResourceCounts slab_resource_counts{};
    KResourceLimit* system_resource_limit{};
@@ -1015,12 +1010,8 @@ Kernel::KScheduler* KernelCore::CurrentScheduler() {
    return impl->schedulers[core_id].get();
 }

-Kernel::TimeManager& KernelCore::TimeManager() {
-    return impl->time_manager;
-}
-
-const Kernel::TimeManager& KernelCore::TimeManager() const {
-    return impl->time_manager;
+Kernel::KHardwareTimer& KernelCore::HardwareTimer() {
+    return *impl->hardware_timer;
 }

 Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() {
@@ -39,6 +39,7 @@ class KDynamicPageManager;
 class KEvent;
 class KEventInfo;
 class KHandleTable;
+class KHardwareTimer;
 class KLinkedListNode;
 class KMemoryLayout;
 class KMemoryManager;
@@ -63,7 +64,6 @@ class KCodeMemory;
 class PhysicalCore;
 class ServiceThread;
 class Synchronization;
-class TimeManager;

 using ServiceInterfaceFactory =
    std::function<KClientPort&(Service::SM::ServiceManager&, Core::System&)>;
@@ -175,11 +175,8 @@ public:
    /// Gets the an instance of the current physical CPU core.
    const Kernel::PhysicalCore& CurrentPhysicalCore() const;

-    /// Gets the an instance of the TimeManager Interface.
-    Kernel::TimeManager& TimeManager();
-
-    /// Gets the an instance of the TimeManager Interface.
-    const Kernel::TimeManager& TimeManager() const;
+    /// Gets the an instance of the hardware timer.
+    Kernel::KHardwareTimer& HardwareTimer();

    /// Stops execution of 'id' core, in order to reschedule a new thread.
    void PrepareReschedule(std::size_t id);
@@ -784,63 +784,29 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
    LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
              info_sub_id, handle);

-    enum class GetInfoType : u64 {
-        // 1.0.0+
-        AllowedCPUCoreMask = 0,
-        AllowedThreadPriorityMask = 1,
-        MapRegionBaseAddr = 2,
-        MapRegionSize = 3,
-        HeapRegionBaseAddr = 4,
-        HeapRegionSize = 5,
-        TotalPhysicalMemoryAvailable = 6,
-        TotalPhysicalMemoryUsed = 7,
-        IsCurrentProcessBeingDebugged = 8,
-        RegisterResourceLimit = 9,
-        IdleTickCount = 10,
-        RandomEntropy = 11,
-        ThreadTickCount = 0xF0000002,
-        // 2.0.0+
-        ASLRRegionBaseAddr = 12,
-        ASLRRegionSize = 13,
-        StackRegionBaseAddr = 14,
-        StackRegionSize = 15,
-        // 3.0.0+
-        SystemResourceSize = 16,
-        SystemResourceUsage = 17,
-        TitleId = 18,
-        // 4.0.0+
-        PrivilegedProcessId = 19,
-        // 5.0.0+
-        UserExceptionContextAddr = 20,
-        // 6.0.0+
-        TotalPhysicalMemoryAvailableWithoutSystemResource = 21,
-        TotalPhysicalMemoryUsedWithoutSystemResource = 22,
-
-        // Homebrew only
-        MesosphereCurrentProcess = 65001,
-    };
-
-    const auto info_id_type = static_cast<GetInfoType>(info_id);
+    const auto info_id_type = static_cast<InfoType>(info_id);

    switch (info_id_type) {
-    case GetInfoType::AllowedCPUCoreMask:
-    case GetInfoType::AllowedThreadPriorityMask:
-    case GetInfoType::MapRegionBaseAddr:
-    case GetInfoType::MapRegionSize:
-    case GetInfoType::HeapRegionBaseAddr:
-    case GetInfoType::HeapRegionSize:
-    case GetInfoType::ASLRRegionBaseAddr:
-    case GetInfoType::ASLRRegionSize:
-    case GetInfoType::StackRegionBaseAddr:
-    case GetInfoType::StackRegionSize:
-    case GetInfoType::TotalPhysicalMemoryAvailable:
-    case GetInfoType::TotalPhysicalMemoryUsed:
-    case GetInfoType::SystemResourceSize:
-    case GetInfoType::SystemResourceUsage:
-    case GetInfoType::TitleId:
-    case GetInfoType::UserExceptionContextAddr:
-    case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
-    case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource: {
+    case InfoType::CoreMask:
+    case InfoType::PriorityMask:
+    case InfoType::AliasRegionAddress:
+    case InfoType::AliasRegionSize:
+    case InfoType::HeapRegionAddress:
+    case InfoType::HeapRegionSize:
+    case InfoType::AslrRegionAddress:
+    case InfoType::AslrRegionSize:
+    case InfoType::StackRegionAddress:
+    case InfoType::StackRegionSize:
+    case InfoType::TotalMemorySize:
+    case InfoType::UsedMemorySize:
+    case InfoType::SystemResourceSizeTotal:
+    case InfoType::SystemResourceSizeUsed:
+    case InfoType::ProgramId:
+    case InfoType::UserExceptionContextAddress:
+    case InfoType::TotalNonSystemMemorySize:
+    case InfoType::UsedNonSystemMemorySize:
+    case InfoType::IsApplication:
+    case InfoType::FreeThreadCount: {
        if (info_sub_id != 0) {
            LOG_ERROR(Kernel_SVC, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
                      info_sub_id);
@@ -856,79 +822,83 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
        }

        switch (info_id_type) {
-        case GetInfoType::AllowedCPUCoreMask:
+        case InfoType::CoreMask:
            *result = process->GetCoreMask();
            return ResultSuccess;

-        case GetInfoType::AllowedThreadPriorityMask:
+        case InfoType::PriorityMask:
            *result = process->GetPriorityMask();
            return ResultSuccess;

-        case GetInfoType::MapRegionBaseAddr:
+        case InfoType::AliasRegionAddress:
            *result = process->PageTable().GetAliasRegionStart();
            return ResultSuccess;

-        case GetInfoType::MapRegionSize:
+        case InfoType::AliasRegionSize:
            *result = process->PageTable().GetAliasRegionSize();
            return ResultSuccess;

-        case GetInfoType::HeapRegionBaseAddr:
+        case InfoType::HeapRegionAddress:
            *result = process->PageTable().GetHeapRegionStart();
            return ResultSuccess;

-        case GetInfoType::HeapRegionSize:
+        case InfoType::HeapRegionSize:
            *result = process->PageTable().GetHeapRegionSize();
            return ResultSuccess;

-        case GetInfoType::ASLRRegionBaseAddr:
+        case InfoType::AslrRegionAddress:
            *result = process->PageTable().GetAliasCodeRegionStart();
            return ResultSuccess;

-        case GetInfoType::ASLRRegionSize:
+        case InfoType::AslrRegionSize:
            *result = process->PageTable().GetAliasCodeRegionSize();
            return ResultSuccess;

-        case GetInfoType::StackRegionBaseAddr:
+        case InfoType::StackRegionAddress:
            *result = process->PageTable().GetStackRegionStart();
            return ResultSuccess;

-        case GetInfoType::StackRegionSize:
+        case InfoType::StackRegionSize:
            *result = process->PageTable().GetStackRegionSize();
            return ResultSuccess;

-        case GetInfoType::TotalPhysicalMemoryAvailable:
+        case InfoType::TotalMemorySize:
            *result = process->GetTotalPhysicalMemoryAvailable();
            return ResultSuccess;

-        case GetInfoType::TotalPhysicalMemoryUsed:
+        case InfoType::UsedMemorySize:
            *result = process->GetTotalPhysicalMemoryUsed();
            return ResultSuccess;

-        case GetInfoType::SystemResourceSize:
+        case InfoType::SystemResourceSizeTotal:
            *result = process->GetSystemResourceSize();
            return ResultSuccess;

-        case GetInfoType::SystemResourceUsage:
+        case InfoType::SystemResourceSizeUsed:
            LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query system resource usage");
            *result = process->GetSystemResourceUsage();
            return ResultSuccess;

-        case GetInfoType::TitleId:
+        case InfoType::ProgramId:
            *result = process->GetProgramID();
            return ResultSuccess;

-        case GetInfoType::UserExceptionContextAddr:
+        case InfoType::UserExceptionContextAddress:
            *result = process->GetProcessLocalRegionAddress();
            return ResultSuccess;

-        case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
+        case InfoType::TotalNonSystemMemorySize:
            *result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();
            return ResultSuccess;

-        case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource:
+        case InfoType::UsedNonSystemMemorySize:
            *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
            return ResultSuccess;

+        case InfoType::FreeThreadCount:
+            *result = process->GetFreeThreadCount();
+            return ResultSuccess;
+
        default:
            break;
        }
@@ -937,11 +907,11 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
        return ResultInvalidEnumValue;
    }

-    case GetInfoType::IsCurrentProcessBeingDebugged:
+    case InfoType::DebuggerAttached:
        *result = 0;
        return ResultSuccess;

-    case GetInfoType::RegisterResourceLimit: {
+    case InfoType::ResourceLimit: {
        if (handle != 0) {
            LOG_ERROR(Kernel, "Handle is non zero! handle={:08X}", handle);
            return ResultInvalidHandle;
@@ -969,7 +939,7 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
        return ResultSuccess;
    }

-    case GetInfoType::RandomEntropy:
+    case InfoType::RandomEntropy:
        if (handle != 0) {
            LOG_ERROR(Kernel_SVC, "Process Handle is non zero, expected 0 result but got {:016X}",
                      handle);
@@ -985,13 +955,13 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
        *result = system.Kernel().CurrentProcess()->GetRandomEntropy(info_sub_id);
        return ResultSuccess;

-    case GetInfoType::PrivilegedProcessId:
+    case InfoType::InitialProcessIdRange:
        LOG_WARNING(Kernel_SVC,
                    "(STUBBED) Attempted to query privileged process id bounds, returned 0");
        *result = 0;
        return ResultSuccess;

-    case GetInfoType::ThreadTickCount: {
+    case InfoType::ThreadTickCount: {
        constexpr u64 num_cpus = 4;
        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
            LOG_ERROR(Kernel_SVC, "Core count is out of range, expected {} but got {}", num_cpus,
@@ -1026,7 +996,7 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
        *result = out_ticks;
        return ResultSuccess;
    }
-    case GetInfoType::IdleTickCount: {
+    case InfoType::IdleTickCount: {
        // Verify the input handle is invalid.
        R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);

@@ -1040,7 +1010,7 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle han
        *result = system.Kernel().CurrentScheduler()->GetIdleThread()->GetCpuTime();
        return ResultSuccess;
    }
-    case GetInfoType::MesosphereCurrentProcess: {
+    case InfoType::MesosphereCurrentProcess: {
        // Verify the input handle is invalid.
        R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);

@@ -1,44 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/assert.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/k_scheduler.h"
-#include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/time_manager.h"
-
-namespace Kernel {
-
-TimeManager::TimeManager(Core::System& system_) : system{system_} {
-    time_manager_event_type = Core::Timing::CreateEvent(
-        "Kernel::TimeManagerCallback",
-        [this](std::uintptr_t thread_handle, s64 time,
-               std::chrono::nanoseconds) -> std::optional<std::chrono::nanoseconds> {
-            KThread* thread = reinterpret_cast<KThread*>(thread_handle);
-            {
-                KScopedSchedulerLock sl(system.Kernel());
-                thread->OnTimer();
-            }
-            return std::nullopt;
-        });
-}
-
-void TimeManager::ScheduleTimeEvent(KThread* thread, s64 nanoseconds) {
-    std::scoped_lock lock{mutex};
-    if (nanoseconds > 0) {
-        ASSERT(thread);
-        ASSERT(thread->GetState() != ThreadState::Runnable);
-        system.CoreTiming().ScheduleEvent(std::chrono::nanoseconds{nanoseconds},
-                                          time_manager_event_type,
-                                          reinterpret_cast<uintptr_t>(thread));
-    }
-}
-
-void TimeManager::UnscheduleTimeEvent(KThread* thread) {
-    std::scoped_lock lock{mutex};
-    system.CoreTiming().UnscheduleEvent(time_manager_event_type,
-                                        reinterpret_cast<uintptr_t>(thread));
-}
-
-} // namespace Kernel
@@ -1,41 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <mutex>
-
-namespace Core {
-class System;
-} // namespace Core
-
-namespace Core::Timing {
-struct EventType;
-} // namespace Core::Timing
-
-namespace Kernel {
-
-class KThread;
-
-/**
- * The `TimeManager` takes care of scheduling time events on threads and executes their TimeUp
- * method when the event is triggered.
- */
-class TimeManager {
-public:
-    explicit TimeManager(Core::System& system);
-
-    /// Schedule a time event on `timetask` thread that will expire in 'nanoseconds'
-    void ScheduleTimeEvent(KThread* time_task, s64 nanoseconds);
-
-    /// Unschedule an existing time event
-    void UnscheduleTimeEvent(KThread* thread);
-
-private:
-    Core::System& system;
-    std::shared_ptr<Core::Timing::EventType> time_manager_event_type;
-    std::mutex mutex;
-};
-
-} // namespace Kernel
@@ -203,8 +203,9 @@ private:
 };

 AudInU::AudInU(Core::System& system_)
-    : ServiceFramework{system_, "audin:u"}, service_context{system_, "AudInU"},
-      impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} {
+    : ServiceFramework{system_, "audin:u", ServiceThreadType::CreateNew},
+      service_context{system_, "AudInU"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
+                                              system_)} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &AudInU::ListAudioIns, "ListAudioIns"},
@@ -26,8 +26,9 @@ public:
    explicit IAudioOut(Core::System& system_, AudioCore::AudioOut::Manager& manager,
                       size_t session_id, const std::string& device_name,
                       const AudioOutParameter& in_params, u32 handle, u64 applet_resource_user_id)
-        : ServiceFramework{system_, "IAudioOut"}, service_context{system_, "IAudioOut"},
-          event{service_context.CreateEvent("AudioOutEvent")},
+        : ServiceFramework{system_, "IAudioOut", ServiceThreadType::CreateNew},
+          service_context{system_, "IAudioOut"}, event{service_context.CreateEvent(
+                                                     "AudioOutEvent")},
          impl{std::make_shared<AudioCore::AudioOut::Out>(system_, manager, event, session_id)} {

        // clang-format off
@@ -220,8 +221,9 @@ private:
 };

 AudOutU::AudOutU(Core::System& system_)
-    : ServiceFramework{system_, "audout:u"}, service_context{system_, "AudOutU"},
-      impl{std::make_unique<AudioCore::AudioOut::Manager>(system_)} {
+    : ServiceFramework{system_, "audout:u", ServiceThreadType::CreateNew},
+      service_context{system_, "AudOutU"}, impl{std::make_unique<AudioCore::AudioOut::Manager>(
+                                               system_)} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &AudOutU::ListAudioOuts, "ListAudioOuts"},
@@ -35,9 +35,10 @@ public:
                            AudioCore::AudioRendererParameterInternal& params,
                            Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                            u32 process_handle, u64 applet_resource_user_id, s32 session_id)
-        : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
-          rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
-          impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
+        : ServiceFramework{system_, "IAudioRenderer", ServiceThreadType::CreateNew},
+          service_context{system_, "IAudioRenderer"}, rendered_event{service_context.CreateEvent(
+                                                          "IAudioRendererEvent")},
+          manager{manager_}, impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {0, &IAudioRenderer::GetSampleRate, "GetSampleRate"},
@@ -242,8 +243,10 @@ class IAudioDevice final : public ServiceFramework<IAudioDevice> {
 public:
    explicit IAudioDevice(Core::System& system_, u64 applet_resource_user_id, u32 revision,
                          u32 device_num)
-        : ServiceFramework{system_, "IAudioDevice"}, service_context{system_, "IAudioDevice"},
-          impl{std::make_unique<AudioDevice>(system_, applet_resource_user_id, revision)},
+        : ServiceFramework{system_, "IAudioDevice", ServiceThreadType::CreateNew},
+          service_context{system_, "IAudioDevice"}, impl{std::make_unique<AudioDevice>(
+                                                        system_, applet_resource_user_id,
+                                                        revision)},
          event{service_context.CreateEvent(fmt::format("IAudioDeviceEvent-{}", device_num))} {
        static const FunctionInfo functions[] = {
            {0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
@@ -418,7 +421,7 @@ private:
 };

 AudRenU::AudRenU(Core::System& system_)
-    : ServiceFramework{system_, "audren:u"},
+    : ServiceFramework{system_, "audren:u", ServiceThreadType::CreateNew},
      service_context{system_, "audren:u"}, impl{std::make_unique<Manager>(system_)} {
    // clang-format off
    static const FunctionInfo functions[] = {
@@ -97,7 +97,7 @@ void IUser::IsNfcEnabled(Kernel::HLERequestContext& ctx) {
 }

 void IUser::ListDevices(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_NFC, "called");
+    LOG_DEBUG(Service_NFC, "called");

    if (state == State::NonInitialized) {
        IPC::ResponseBuilder rb{ctx, 2};
@@ -83,7 +83,7 @@ void IUser::Finalize(Kernel::HLERequestContext& ctx) {
 }

 void IUser::ListDevices(Kernel::HLERequestContext& ctx) {
-    LOG_INFO(Service_NFP, "called");
+    LOG_DEBUG(Service_NFP, "called");

    if (state == State::NonInitialized) {
        IPC::ResponseBuilder rb{ctx, 2};
--- a/Show More
+++ b/Show More