Android #118

android: Simplify game card layout

.ci/scripts/clang/docker.sh

@@ -19,6 +19,7 @@ cmake .. \
       -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
       -DENABLE_QT_TRANSLATION=ON \
       -DUSE_DISCORD_PRESENCE=ON \
+      -DYUZU_CRASH_DUMPS=ON \
       -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
       -DYUZU_USE_BUNDLED_FFMPEG=ON \
       -GNinja

.ci/scripts/linux/docker.sh

@@ -23,6 +23,7 @@ cmake .. \
       -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
       -DYUZU_USE_BUNDLED_FFMPEG=ON \
       -DYUZU_ENABLE_LTO=ON \
+      -DYUZU_CRASH_DUMPS=ON \
       -GNinja
 
 ninja

.ci/scripts/windows/docker.sh

@@ -17,7 +17,6 @@ cmake .. \
     -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
     -DENABLE_QT_TRANSLATION=ON \
     -DUSE_CCACHE=ON \
-    -DYUZU_CRASH_DUMPS=ON \
     -DYUZU_USE_BUNDLED_SDL2=OFF \
     -DYUZU_USE_EXTERNAL_SDL2=OFF \
     -DYUZU_TESTS=OFF \

.gitmodules

@@ -32,7 +32,7 @@
 	path = externals/xbyak
 	url = https://github.com/herumi/xbyak.git
 [submodule "opus"]
-	path = externals/opus/opus
+	path = externals/opus
 	url = https://github.com/xiph/opus.git
 [submodule "SDL"]
 	path = externals/SDL
@@ -58,3 +58,6 @@
 [submodule "VulkanMemoryAllocator"]
 	path = externals/VulkanMemoryAllocator
 	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
+[submodule "breakpad"]
+	path = externals/breakpad
+	url = https://github.com/yuzu-emu/breakpad.git

.reuse/dep5

@@ -147,3 +147,7 @@ License: GPL-3.0-or-later
 Files: src/android/gradle/wrapper/*
 Copyright: 2023 yuzu Emulator Project
 License: GPL-3.0-or-later
+
+Files: externals/stb/*
+Copyright: Sean Barrett
+License: MIT

CMakeLists.txt

@@ -52,7 +52,7 @@ option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android"
 
 CMAKE_DEPENDENT_OPTION(YUZU_ROOM "Compile LDN room server" ON "NOT ANDROID" OFF)
 
-CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile Windows crash dump (Minidump) support" OFF "WIN32" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
 
 option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")
 
@@ -139,9 +139,6 @@ if (YUZU_USE_BUNDLED_VCPKG)
     if (YUZU_TESTS)
         list(APPEND VCPKG_MANIFEST_FEATURES "yuzu-tests")
     endif()
-    if (YUZU_CRASH_DUMPS)
-        list(APPEND VCPKG_MANIFEST_FEATURES "dbghelp")
-    endif()
     if (ENABLE_WEB_SERVICE)
         list(APPEND VCPKG_MANIFEST_FEATURES "web-service")
     endif()
@@ -294,6 +291,7 @@ find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3 MODULE)
 find_package(RenderDoc MODULE)
+find_package(stb MODULE)
 find_package(VulkanMemoryAllocator CONFIG)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
@@ -550,6 +548,18 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
     find_package(FFmpeg 4.3 REQUIRED QUIET COMPONENTS ${FFmpeg_COMPONENTS})
 endif()
 
+if (WIN32 AND YUZU_CRASH_DUMPS)
+    set(BREAKPAD_VER "breakpad-c89f9dd")
+    download_bundled_external("breakpad/" ${BREAKPAD_VER} BREAKPAD_PREFIX)
+
+    set(BREAKPAD_CLIENT_INCLUDE_DIR "${BREAKPAD_PREFIX}/include")
+    set(BREAKPAD_CLIENT_LIBRARY "${BREAKPAD_PREFIX}/lib/libbreakpad_client.lib")
+
+    add_library(libbreakpad_client INTERFACE IMPORTED)
+    target_link_libraries(libbreakpad_client INTERFACE "${BREAKPAD_CLIENT_LIBRARY}")
+    target_include_directories(libbreakpad_client INTERFACE "${BREAKPAD_CLIENT_INCLUDE_DIR}")
+endif()
+
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
@@ -569,13 +579,6 @@ elseif (WIN32)
         # PSAPI is the Process Status API
         set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version)
     endif()
-
-    if (YUZU_CRASH_DUMPS)
-        find_library(DBGHELP_LIBRARY dbghelp)
-        if ("${DBGHELP_LIBRARY}" STREQUAL "DBGHELP_LIBRARY-NOTFOUND")
-            message(FATAL_ERROR "YUZU_CRASH_DUMPS enabled but dbghelp library not found")
-        endif()
-    endif()
 elseif (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU|SunOS)$")
     set(PLATFORM_LIBRARIES rt)
 endif()

CMakeModules/Findstb.cmake

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: 2023 Alexandre Bouvier <contact@amb.tf>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+find_path(stb_image_INCLUDE_DIR stb_image.h PATH_SUFFIXES stb)
+find_path(stb_image_resize_INCLUDE_DIR stb_image_resize.h PATH_SUFFIXES stb)
+find_path(stb_image_write_INCLUDE_DIR stb_image_write.h PATH_SUFFIXES stb)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(stb
+    REQUIRED_VARS
+        stb_image_INCLUDE_DIR
+        stb_image_resize_INCLUDE_DIR
+        stb_image_write_INCLUDE_DIR
+)
+
+if (stb_FOUND AND NOT TARGET stb::headers)
+    add_library(stb::headers INTERFACE IMPORTED)
+    set_property(TARGET stb::headers PROPERTY
+        INTERFACE_INCLUDE_DIRECTORIES
+            "${stb_image_INCLUDE_DIR}"
+            "${stb_image_resize_INCLUDE_DIR}"
+            "${stb_image_write_INCLUDE_DIR}"
+    )
+endif()
+
+mark_as_advanced(
+    stb_image_INCLUDE_DIR
+    stb_image_resize_INCLUDE_DIR
+    stb_image_write_INCLUDE_DIR
+)

README.md

@@ -1,3 +1,11 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

dist/org.yuzu_emu.yuzu.desktop

@@ -13,3 +13,4 @@ Exec=yuzu %f
 Categories=Game;Emulator;Qt;
 MimeType=application/x-nx-nro;application/x-nx-nso;application/x-nx-nsp;application/x-nx-xci;
 Keywords=Nintendo;Switch;
+StartupWMClass=yuzu

externals/CMakeLists.txt

@@ -134,6 +134,10 @@ endif()
 
 # Opus
 if (NOT TARGET Opus::opus)
+    set(OPUS_BUILD_TESTING OFF)
+    set(OPUS_BUILD_PROGRAMS OFF)
+    set(OPUS_INSTALL_PKG_CONFIG_MODULE OFF)
+    set(OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF)
     add_subdirectory(opus)
 endif()
 
@@ -168,9 +172,13 @@ if (NOT TARGET LLVM::Demangle)
     add_library(LLVM::Demangle ALIAS demangle)
 endif()
 
-add_library(stb stb/stb_dxt.cpp stb/stb_image.cpp stb/stb_image_resize.cpp)
+add_library(stb stb/stb_dxt.cpp)
 target_include_directories(stb PUBLIC ./stb)
 
+if (NOT TARGET stb::headers)
+    add_library(stb::headers ALIAS stb)
+endif()
+
 add_library(bc_decoder bc_decoder/bc_decoder.cpp)
 target_include_directories(bc_decoder PUBLIC ./bc_decoder)
 
@@ -185,3 +193,105 @@ if (ANDROID)
        add_subdirectory(libadrenotools)
    endif()
 endif()
+
+# Breakpad
+# https://github.com/microsoft/vcpkg/blob/master/ports/breakpad/CMakeLists.txt
+if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
+    set(BREAKPAD_WIN32_DEFINES
+        NOMINMAX
+        UNICODE
+        WIN32_LEAN_AND_MEAN
+        _CRT_SECURE_NO_WARNINGS
+        _CRT_SECURE_NO_DEPRECATE
+        _CRT_NONSTDC_NO_DEPRECATE
+    )
+
+    # libbreakpad
+    add_library(libbreakpad STATIC)
+    file(GLOB_RECURSE LIBBREAKPAD_SOURCES breakpad/src/processor/*.cc)
+    file(GLOB_RECURSE LIBDISASM_SOURCES breakpad/src/third_party/libdisasm/*.c)
+    list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "_unittest|_selftest|synth_minidump|/tests|/testdata|/solaris|microdump_stackwalk|minidump_dump|minidump_stackwalk")
+    if (WIN32)
+        list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "/linux|/mac|/android")
+        target_compile_definitions(libbreakpad PRIVATE ${BREAKPAD_WIN32_DEFINES})
+        target_include_directories(libbreakpad PRIVATE "${CMAKE_GENERATOR_INSTANCE}/DIA SDK/include")
+    elseif (APPLE)
+        list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "/linux|/windows|/android")
+    else()
+        list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "/mac|/windows|/android")
+    endif()
+    target_sources(libbreakpad PRIVATE ${LIBBREAKPAD_SOURCES} ${LIBDISASM_SOURCES})
+    target_include_directories(libbreakpad
+        PUBLIC
+            ${CMAKE_CURRENT_SOURCE_DIR}/breakpad/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/breakpad/src/third_party/libdisasm
+    )
+
+    # libbreakpad_client
+    add_library(libbreakpad_client STATIC)
+    file(GLOB LIBBREAKPAD_COMMON_SOURCES breakpad/src/common/*.cc breakpad/src/common/*.c breakpad/src/client/*.cc)
+
+    if (WIN32)
+        file(GLOB_RECURSE LIBBREAKPAD_CLIENT_SOURCES breakpad/src/client/windows/*.cc breakpad/src/common/windows/*.cc)
+        list(FILTER LIBBREAKPAD_COMMON_SOURCES EXCLUDE REGEX "language.cc|path_helper.cc|stabs_to_module.cc|stabs_reader.cc|minidump_file_writer.cc")
+        target_include_directories(libbreakpad_client PRIVATE "${CMAKE_GENERATOR_INSTANCE}/DIA SDK/include")
+        target_compile_definitions(libbreakpad_client PRIVATE ${BREAKPAD_WIN32_DEFINES})
+    elseif (APPLE)
+        target_compile_definitions(libbreakpad_client PRIVATE HAVE_MACH_O_NLIST_H)
+        file(GLOB_RECURSE LIBBREAKPAD_CLIENT_SOURCES breakpad/src/client/mac/*.cc breakpad/src/common/mac/*.cc)
+        list(APPEND LIBBREAKPAD_CLIENT_SOURCES breakpad/src/common/mac/MachIPC.mm)
+    else()
+        target_compile_definitions(libbreakpad_client PUBLIC -DHAVE_A_OUT_H)
+        file(GLOB_RECURSE LIBBREAKPAD_CLIENT_SOURCES breakpad/src/client/linux/*.cc breakpad/src/common/linux/*.cc)
+    endif()
+    list(APPEND LIBBREAKPAD_CLIENT_SOURCES ${LIBBREAKPAD_COMMON_SOURCES})
+    list(FILTER LIBBREAKPAD_CLIENT_SOURCES EXCLUDE REGEX "/sender|/tests|/unittests|/testcases|_unittest|_test")
+    target_sources(libbreakpad_client PRIVATE ${LIBBREAKPAD_CLIENT_SOURCES})
+    target_include_directories(libbreakpad_client PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/breakpad/src)
+
+    if (WIN32)
+        target_link_libraries(libbreakpad_client PRIVATE wininet.lib)
+    elseif (APPLE)
+        find_library(CoreFoundation_FRAMEWORK CoreFoundation)
+        target_link_libraries(libbreakpad_client PRIVATE ${CoreFoundation_FRAMEWORK})
+    else()
+        find_library(PTHREAD_LIBRARIES pthread)
+        target_compile_definitions(libbreakpad_client PRIVATE HAVE_GETCONTEXT=1)
+        if (PTHREAD_LIBRARIES)
+            target_link_libraries(libbreakpad_client PRIVATE ${PTHREAD_LIBRARIES})
+        endif()
+    endif()
+
+    # Host tools for symbol processing
+    if (LINUX)
+        find_package(ZLIB REQUIRED)
+
+        add_executable(minidump_stackwalk breakpad/src/processor/minidump_stackwalk.cc)
+        target_link_libraries(minidump_stackwalk PRIVATE libbreakpad libbreakpad_client)
+
+        add_executable(dump_syms
+            breakpad/src/common/dwarf_cfi_to_module.cc
+            breakpad/src/common/dwarf_cu_to_module.cc
+            breakpad/src/common/dwarf_line_to_module.cc
+            breakpad/src/common/dwarf_range_list_handler.cc
+            breakpad/src/common/language.cc
+            breakpad/src/common/module.cc
+            breakpad/src/common/path_helper.cc
+            breakpad/src/common/stabs_reader.cc
+            breakpad/src/common/stabs_to_module.cc
+            breakpad/src/common/dwarf/bytereader.cc
+            breakpad/src/common/dwarf/dwarf2diehandler.cc
+            breakpad/src/common/dwarf/dwarf2reader.cc
+            breakpad/src/common/dwarf/elf_reader.cc
+            breakpad/src/common/linux/crc32.cc
+            breakpad/src/common/linux/dump_symbols.cc
+            breakpad/src/common/linux/elf_symbols_to_module.cc
+            breakpad/src/common/linux/elfutils.cc
+            breakpad/src/common/linux/file_id.cc
+            breakpad/src/common/linux/linux_libc_support.cc
+            breakpad/src/common/linux/memory_mapped_file.cc
+            breakpad/src/common/linux/safe_readlink.cc
+            breakpad/src/tools/linux/dump_syms/dump_syms.cc)
+        target_link_libraries(dump_syms PRIVATE libbreakpad_client ZLIB::ZLIB)
+    endif()
+endif()

externals/libusb/CMakeLists.txt

@@ -49,11 +49,6 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
 
     set(LIBUSB_INCLUDE_DIRS "${LIBUSB_SRC_DIR}/libusb" CACHE PATH "libusb headers path" FORCE)
 
-    # MINGW: causes "externals/libusb/libusb/libusb/os/windows_winusb.c:1427:2: error: conversion to non-scalar type requested", so cannot statically link it for now.
-    if (NOT MINGW)
-        set(LIBUSB_CFLAGS "-DGUID_DEVINTERFACE_USB_DEVICE=\\(GUID\\){0xA5DCBF10,0x6530,0x11D2,{0x90,0x1F,0x00,0xC0,0x4F,0xB9,0x51,0xED}}")
-    endif()
-
     make_directory("${LIBUSB_PREFIX}")
 
     add_custom_command(
@@ -146,8 +141,6 @@ else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
             target_include_directories(usb BEFORE PRIVATE libusb/msvc)
         endif()
 
-        # Works around other libraries providing their own definition of USB GUIDs (e.g. SDL2)
-        target_compile_definitions(usb PRIVATE "-DGUID_DEVINTERFACE_USB_DEVICE=(GUID){ 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED}}")
     else()
         target_include_directories(usb
             # turns out other projects also have "config.h", so make sure the

externals/opus/CMakeLists.txt

@@ -1,259 +0,0 @@
-# SPDX-FileCopyrightText: 2019 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-cmake_minimum_required(VERSION 3.8)
-
-project(opus)
-
-option(OPUS_STACK_PROTECTOR "Use stack protection" OFF)
-option(OPUS_USE_ALLOCA "Use alloca for stack arrays (on non-C99 compilers)" OFF)
-option(OPUS_CUSTOM_MODES "Enable non-Opus modes, e.g. 44.1 kHz & 2^n frames" OFF)
-option(OPUS_FIXED_POINT "Compile as fixed-point (for machines without a fast enough FPU)" OFF)
-option(OPUS_ENABLE_FLOAT_API "Compile with the floating point API (for machines with float library" ON)
-
-include(opus/opus_functions.cmake)
-
-if(OPUS_STACK_PROTECTOR)
-    if(NOT MSVC) # GC on by default on MSVC
-        check_and_set_flag(STACK_PROTECTION_STRONG -fstack-protector-strong)
-    endif()
-else()
-    if(MSVC)
-        check_and_set_flag(BUFFER_SECURITY_CHECK /GS-)
-    endif()
-endif()
-
-add_library(opus
-    # CELT sources
-    opus/celt/bands.c
-    opus/celt/celt.c
-    opus/celt/celt_decoder.c
-    opus/celt/celt_encoder.c
-    opus/celt/celt_lpc.c
-    opus/celt/cwrs.c
-    opus/celt/entcode.c
-    opus/celt/entdec.c
-    opus/celt/entenc.c
-    opus/celt/kiss_fft.c
-    opus/celt/laplace.c
-    opus/celt/mathops.c
-    opus/celt/mdct.c
-    opus/celt/modes.c
-    opus/celt/pitch.c
-    opus/celt/quant_bands.c
-    opus/celt/rate.c
-    opus/celt/vq.c
-
-    # SILK sources
-    opus/silk/A2NLSF.c
-    opus/silk/CNG.c
-    opus/silk/HP_variable_cutoff.c
-    opus/silk/LPC_analysis_filter.c
-    opus/silk/LPC_fit.c
-    opus/silk/LPC_inv_pred_gain.c
-    opus/silk/LP_variable_cutoff.c
-    opus/silk/NLSF2A.c
-    opus/silk/NLSF_VQ.c
-    opus/silk/NLSF_VQ_weights_laroia.c
-    opus/silk/NLSF_decode.c
-    opus/silk/NLSF_del_dec_quant.c
-    opus/silk/NLSF_encode.c
-    opus/silk/NLSF_stabilize.c
-    opus/silk/NLSF_unpack.c
-    opus/silk/NSQ.c
-    opus/silk/NSQ_del_dec.c
-    opus/silk/PLC.c
-    opus/silk/VAD.c
-    opus/silk/VQ_WMat_EC.c
-    opus/silk/ana_filt_bank_1.c
-    opus/silk/biquad_alt.c
-    opus/silk/bwexpander.c
-    opus/silk/bwexpander_32.c
-    opus/silk/check_control_input.c
-    opus/silk/code_signs.c
-    opus/silk/control_SNR.c
-    opus/silk/control_audio_bandwidth.c
-    opus/silk/control_codec.c
-    opus/silk/dec_API.c
-    opus/silk/decode_core.c
-    opus/silk/decode_frame.c
-    opus/silk/decode_indices.c
-    opus/silk/decode_parameters.c
-    opus/silk/decode_pitch.c
-    opus/silk/decode_pulses.c
-    opus/silk/decoder_set_fs.c
-    opus/silk/enc_API.c
-    opus/silk/encode_indices.c
-    opus/silk/encode_pulses.c
-    opus/silk/gain_quant.c
-    opus/silk/init_decoder.c
-    opus/silk/init_encoder.c
-    opus/silk/inner_prod_aligned.c
-    opus/silk/interpolate.c
-    opus/silk/lin2log.c
-    opus/silk/log2lin.c
-    opus/silk/pitch_est_tables.c
-    opus/silk/process_NLSFs.c
-    opus/silk/quant_LTP_gains.c
-    opus/silk/resampler.c
-    opus/silk/resampler_down2.c
-    opus/silk/resampler_down2_3.c
-    opus/silk/resampler_private_AR2.c
-    opus/silk/resampler_private_IIR_FIR.c
-    opus/silk/resampler_private_down_FIR.c
-    opus/silk/resampler_private_up2_HQ.c
-    opus/silk/resampler_rom.c
-    opus/silk/shell_coder.c
-    opus/silk/sigm_Q15.c
-    opus/silk/sort.c
-    opus/silk/stereo_LR_to_MS.c
-    opus/silk/stereo_MS_to_LR.c
-    opus/silk/stereo_decode_pred.c
-    opus/silk/stereo_encode_pred.c
-    opus/silk/stereo_find_predictor.c
-    opus/silk/stereo_quant_pred.c
-    opus/silk/sum_sqr_shift.c
-    opus/silk/table_LSF_cos.c
-    opus/silk/tables_LTP.c
-    opus/silk/tables_NLSF_CB_NB_MB.c
-    opus/silk/tables_NLSF_CB_WB.c
-    opus/silk/tables_gain.c
-    opus/silk/tables_other.c
-    opus/silk/tables_pitch_lag.c
-    opus/silk/tables_pulses_per_block.c
-
-    # Opus sources
-    opus/src/analysis.c
-    opus/src/mapping_matrix.c
-    opus/src/mlp.c
-    opus/src/mlp_data.c
-    opus/src/opus.c
-    opus/src/opus_decoder.c
-    opus/src/opus_encoder.c
-    opus/src/opus_multistream.c
-    opus/src/opus_multistream_decoder.c
-    opus/src/opus_multistream_encoder.c
-    opus/src/opus_projection_decoder.c
-    opus/src/opus_projection_encoder.c
-    opus/src/repacketizer.c
-)
-
-if (DEBUG)
-    target_sources(opus PRIVATE opus/silk/debug.c)
-endif()
-
-if (OPUS_FIXED_POINT)
-    target_sources(opus PRIVATE
-        opus/silk/fixed/LTP_analysis_filter_FIX.c
-        opus/silk/fixed/LTP_scale_ctrl_FIX.c
-        opus/silk/fixed/apply_sine_window_FIX.c
-        opus/silk/fixed/autocorr_FIX.c
-        opus/silk/fixed/burg_modified_FIX.c
-        opus/silk/fixed/corrMatrix_FIX.c
-        opus/silk/fixed/encode_frame_FIX.c
-        opus/silk/fixed/find_LPC_FIX.c
-        opus/silk/fixed/find_LTP_FIX.c
-        opus/silk/fixed/find_pitch_lags_FIX.c
-        opus/silk/fixed/find_pred_coefs_FIX.c
-        opus/silk/fixed/k2a_FIX.c
-        opus/silk/fixed/k2a_Q16_FIX.c
-        opus/silk/fixed/noise_shape_analysis_FIX.c
-        opus/silk/fixed/pitch_analysis_core_FIX.c
-        opus/silk/fixed/prefilter_FIX.c
-        opus/silk/fixed/process_gains_FIX.c
-        opus/silk/fixed/regularize_correlations_FIX.c
-        opus/silk/fixed/residual_energy16_FIX.c
-        opus/silk/fixed/residual_energy_FIX.c
-        opus/silk/fixed/schur64_FIX.c
-        opus/silk/fixed/schur_FIX.c
-        opus/silk/fixed/solve_LS_FIX.c
-        opus/silk/fixed/vector_ops_FIX.c
-        opus/silk/fixed/warped_autocorrelation_FIX.c
-    )
-else()
-    target_sources(opus PRIVATE
-        opus/silk/float/LPC_analysis_filter_FLP.c
-        opus/silk/float/LPC_inv_pred_gain_FLP.c
-        opus/silk/float/LTP_analysis_filter_FLP.c
-        opus/silk/float/LTP_scale_ctrl_FLP.c
-        opus/silk/float/apply_sine_window_FLP.c
-        opus/silk/float/autocorrelation_FLP.c
-        opus/silk/float/burg_modified_FLP.c
-        opus/silk/float/bwexpander_FLP.c
-        opus/silk/float/corrMatrix_FLP.c
-        opus/silk/float/encode_frame_FLP.c
-        opus/silk/float/energy_FLP.c
-        opus/silk/float/find_LPC_FLP.c
-        opus/silk/float/find_LTP_FLP.c
-        opus/silk/float/find_pitch_lags_FLP.c
-        opus/silk/float/find_pred_coefs_FLP.c
-        opus/silk/float/inner_product_FLP.c
-        opus/silk/float/k2a_FLP.c
-        opus/silk/float/noise_shape_analysis_FLP.c
-        opus/silk/float/pitch_analysis_core_FLP.c
-        opus/silk/float/process_gains_FLP.c
-        opus/silk/float/regularize_correlations_FLP.c
-        opus/silk/float/residual_energy_FLP.c
-        opus/silk/float/scale_copy_vector_FLP.c
-        opus/silk/float/scale_vector_FLP.c
-        opus/silk/float/schur_FLP.c
-        opus/silk/float/sort_FLP.c
-        opus/silk/float/warped_autocorrelation_FLP.c
-        opus/silk/float/wrappers_FLP.c
-    )
-endif()
-
-target_compile_definitions(opus PRIVATE OPUS_BUILD ENABLE_HARDENING)
-
-if(NOT MSVC)
-    if(MINGW)
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=0)
-    else()
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
-    endif()
-endif()
-
-# It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
-# variable-length arrays for stack allocation USE_ALLOCA: Use alloca() for stack
-# allocation If none is defined, then the fallback is a non-threadsafe global
-# array
-if(OPUS_USE_ALLOCA OR MSVC)
-    target_compile_definitions(opus PRIVATE USE_ALLOCA)
-else()
-    target_compile_definitions(opus PRIVATE VAR_ARRAYS)
-endif()
-
-if(OPUS_CUSTOM_MODES)
-    target_compile_definitions(opus PRIVATE CUSTOM_MODES)
-endif()
-
-if(NOT OPUS_ENABLE_FLOAT_API)
-    target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
-endif()
-
-target_compile_definitions(opus
-PUBLIC
-    -DOPUS_VERSION="\\"1.3.1\\""
-
-PRIVATE
-    # Use C99 intrinsics to speed up float-to-int conversion
-    HAVE_LRINTF
-)
-
-if (FIXED_POINT)
-    target_compile_definitions(opus PRIVATE -DFIXED_POINT=1 -DDISABLE_FLOAT_API)
-endif()
-
-target_include_directories(opus
-PUBLIC
-    opus/include
-
-PRIVATE
-    opus/celt
-    opus/silk
-    opus/silk/fixed
-    opus/silk/float
-    opus/src
-)
-
-add_library(Opus::opus ALIAS opus)

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -5,6 +5,7 @@ package org.yuzu.yuzu_emu
 
 import android.app.Dialog
 import android.content.DialogInterface
+import android.net.Uri
 import android.os.Bundle
 import android.text.Html
 import android.text.method.LinkMovementMethod
@@ -16,7 +17,7 @@ import androidx.fragment.app.DialogFragment
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import java.lang.ref.WeakReference
 import org.yuzu.yuzu_emu.activities.EmulationActivity
-import org.yuzu.yuzu_emu.utils.DocumentsTree.Companion.isNativePath
+import org.yuzu.yuzu_emu.utils.DocumentsTree
 import org.yuzu.yuzu_emu.utils.FileUtil
 import org.yuzu.yuzu_emu.utils.Log
 import org.yuzu.yuzu_emu.utils.SerializableHelper.serializable
@@ -68,7 +69,7 @@ object NativeLibrary {
     @Keep
     @JvmStatic
     fun openContentUri(path: String?, openmode: String?): Int {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
             YuzuApplication.documentsTree!!.openContentUri(path, openmode)
         } else {
             FileUtil.openContentUri(path, openmode)
@@ -78,7 +79,7 @@ object NativeLibrary {
     @Keep
     @JvmStatic
     fun getSize(path: String?): Long {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
             YuzuApplication.documentsTree!!.getFileSize(path)
         } else {
             FileUtil.getFileSize(path)
@@ -88,23 +89,41 @@ object NativeLibrary {
     @Keep
     @JvmStatic
     fun exists(path: String?): Boolean {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
             YuzuApplication.documentsTree!!.exists(path)
         } else {
-            FileUtil.exists(path)
+            FileUtil.exists(path, suppressLog = true)
         }
     }
 
     @Keep
     @JvmStatic
     fun isDirectory(path: String?): Boolean {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
             YuzuApplication.documentsTree!!.isDirectory(path)
         } else {
             FileUtil.isDirectory(path)
         }
     }
 
+    @Keep
+    @JvmStatic
+    fun getParentDirectory(path: String): String =
+        if (DocumentsTree.isNativePath(path)) {
+            YuzuApplication.documentsTree!!.getParentDirectory(path)
+        } else {
+            path
+        }
+
+    @Keep
+    @JvmStatic
+    fun getFilename(path: String): String =
+        if (DocumentsTree.isNativePath(path)) {
+            YuzuApplication.documentsTree!!.getFilename(path)
+        } else {
+            FileUtil.getFilename(Uri.parse(path))
+        }
+
     /**
      * Returns true if pro controller isn't available and handheld is
      */
@@ -215,32 +234,6 @@ object NativeLibrary {
 
     external fun initGameIni(gameID: String?)
 
-    /**
-     * Gets the embedded icon within the given ROM.
-     *
-     * @param filename the file path to the ROM.
-     * @return a byte array containing the JPEG data for the icon.
-     */
-    external fun getIcon(filename: String): ByteArray
-
-    /**
-     * Gets the embedded title of the given ISO/ROM.
-     *
-     * @param filename The file path to the ISO/ROM.
-     * @return the embedded title of the ISO/ROM.
-     */
-    external fun getTitle(filename: String): String
-
-    external fun getDescription(filename: String): String
-
-    external fun getGameId(filename: String): String
-
-    external fun getRegions(filename: String): String
-
-    external fun getCompany(filename: String): String
-
-    external fun isHomebrew(filename: String): Boolean
-
     external fun setAppDirectory(directory: String)
 
     /**
@@ -293,11 +286,6 @@ object NativeLibrary {
      */
     external fun stopEmulation()
 
-    /**
-     * Resets the in-memory ROM metadata cache.
-     */
-    external fun resetRomMetadata()
-
     /**
      * Returns true if emulation is running (or is paused).
      */

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt

@@ -147,7 +147,7 @@ class GameAdapter(private val activity: AppCompatActivity) :
 
     private class DiffCallback : DiffUtil.ItemCallback<Game>() {
         override fun areItemsTheSame(oldItem: Game, newItem: Game): Boolean {
-            return oldItem.gameId == newItem.gameId
+            return oldItem.programId == newItem.programId
         }
 
         override fun areContentsTheSame(oldItem: Game, newItem: Game): Boolean {

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -15,6 +15,7 @@ import android.net.Uri
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.os.SystemClock
 import android.view.*
 import android.widget.TextView
 import android.widget.Toast
@@ -25,6 +26,7 @@ import androidx.core.graphics.Insets
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.drawerlayout.widget.DrawerLayout
+import androidx.drawerlayout.widget.DrawerLayout.DrawerListener
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
 import androidx.lifecycle.Lifecycle
@@ -156,6 +158,32 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         binding.showFpsText.setTextColor(Color.YELLOW)
         binding.doneControlConfig.setOnClickListener { stopConfiguringControls() }
 
+        binding.drawerLayout.addDrawerListener(object : DrawerListener {
+            override fun onDrawerSlide(drawerView: View, slideOffset: Float) {
+                binding.surfaceInputOverlay.dispatchTouchEvent(
+                    MotionEvent.obtain(
+                        SystemClock.uptimeMillis(),
+                        SystemClock.uptimeMillis() + 100,
+                        MotionEvent.ACTION_UP,
+                        0f,
+                        0f,
+                        0
+                    )
+                )
+            }
+
+            override fun onDrawerOpened(drawerView: View) {
+                // No op
+            }
+
+            override fun onDrawerClosed(drawerView: View) {
+                // No op
+            }
+
+            override fun onDrawerStateChanged(newState: Int) {
+                // No op
+            }
+        })
         binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
         binding.inGameMenu.getHeaderView(0).findViewById<TextView>(R.id.text_game_title).text =
             game.title

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/HomeSettingsFragment.kt

@@ -26,7 +26,7 @@ import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
 import androidx.navigation.findNavController
 import androidx.navigation.fragment.findNavController
-import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.GridLayoutManager
 import com.google.android.material.transition.MaterialSharedAxis
 import org.yuzu.yuzu_emu.BuildConfig
 import org.yuzu.yuzu_emu.HomeNavigationDirections
@@ -186,7 +186,8 @@ class HomeSettingsFragment : Fragment() {
         }
 
         binding.homeSettingsList.apply {
-            layoutManager = LinearLayoutManager(requireContext())
+            layoutManager =
+                GridLayoutManager(requireContext(), resources.getInteger(R.integer.grid_columns))
             adapter = HomeSettingAdapter(
                 requireActivity() as AppCompatActivity,
                 viewLifecycleOwner,

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/Game.kt

@@ -12,15 +12,14 @@ import kotlinx.serialization.Serializable
 @Serializable
 class Game(
     val title: String,
-    val description: String,
-    val regions: String,
     val path: String,
-    val gameId: String,
-    val company: String,
+    val programId: String,
+    val developer: String,
+    val version: String,
     val isHomebrew: Boolean
 ) : Parcelable {
-    val keyAddedToLibraryTime get() = "${gameId}_AddedToLibraryTime"
-    val keyLastPlayedTime get() = "${gameId}_LastPlayed"
+    val keyAddedToLibraryTime get() = "${programId}_AddedToLibraryTime"
+    val keyLastPlayedTime get() = "${programId}_LastPlayed"
 
     override fun equals(other: Any?): Boolean {
         if (other !is Game) {
@@ -32,11 +31,9 @@ class Game(
 
     override fun hashCode(): Int {
         var result = title.hashCode()
-        result = 31 * result + description.hashCode()
-        result = 31 * result + regions.hashCode()
         result = 31 * result + path.hashCode()
-        result = 31 * result + gameId.hashCode()
-        result = 31 * result + company.hashCode()
+        result = 31 * result + programId.hashCode()
+        result = 31 * result + developer.hashCode()
         result = 31 * result + isHomebrew.hashCode()
         return result
     }

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt

@@ -14,15 +14,13 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.MissingFieldException
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.json.Json
 import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.YuzuApplication
 import org.yuzu.yuzu_emu.utils.GameHelper
+import org.yuzu.yuzu_emu.utils.GameMetadata
 
-@OptIn(ExperimentalSerializationApi::class)
 class GamesViewModel : ViewModel() {
     val games: StateFlow<List<Game>> get() = _games
     private val _games = MutableStateFlow(emptyList<Game>())
@@ -49,26 +47,34 @@ class GamesViewModel : ViewModel() {
         // Retrieve list of cached games
         val storedGames = PreferenceManager.getDefaultSharedPreferences(YuzuApplication.appContext)
             .getStringSet(GameHelper.KEY_GAMES, emptySet())
-        if (storedGames!!.isNotEmpty()) {
-            val deserializedGames = mutableSetOf<Game>()
-            storedGames.forEach {
-                val game: Game
-                try {
-                    game = Json.decodeFromString(it)
-                } catch (e: MissingFieldException) {
-                    return@forEach
-                }
 
-                val gameExists =
-                    DocumentFile.fromSingleUri(YuzuApplication.appContext, Uri.parse(game.path))
-                        ?.exists()
-                if (gameExists == true) {
-                    deserializedGames.add(game)
+        viewModelScope.launch {
+            withContext(Dispatchers.IO) {
+                if (storedGames!!.isNotEmpty()) {
+                    val deserializedGames = mutableSetOf<Game>()
+                    storedGames.forEach {
+                        val game: Game
+                        try {
+                            game = Json.decodeFromString(it)
+                        } catch (e: Exception) {
+                            // We don't care about any errors related to parsing the game cache
+                            return@forEach
+                        }
+
+                        val gameExists =
+                            DocumentFile.fromSingleUri(
+                                YuzuApplication.appContext,
+                                Uri.parse(game.path)
+                            )?.exists()
+                        if (gameExists == true) {
+                            deserializedGames.add(game)
+                        }
+                    }
+                    setGames(deserializedGames.toList())
                 }
+                reloadGames(false)
             }
-            setGames(deserializedGames.toList())
         }
-        reloadGames(false)
     }
 
     fun setGames(games: List<Game>) {
@@ -106,7 +112,7 @@ class GamesViewModel : ViewModel() {
 
         viewModelScope.launch {
             withContext(Dispatchers.IO) {
-                NativeLibrary.resetRomMetadata()
+                GameMetadata.resetMetadata()
                 setGames(GameHelper.getGames())
                 _isReloading.value = false
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/DocumentsTree.kt

@@ -42,6 +42,23 @@ class DocumentsTree {
         return node != null && node.isDirectory
     }
 
+    fun getParentDirectory(filepath: String): String {
+        val node = resolvePath(filepath)!!
+        val parentNode = node.parent
+        if (parentNode != null && parentNode.isDirectory) {
+            return parentNode.uri!!.toString()
+        }
+        return node.uri!!.toString()
+    }
+
+    fun getFilename(filepath: String): String {
+        val node = resolvePath(filepath)
+        if (node != null) {
+            return node.name!!
+        }
+        return filepath
+    }
+
     private fun resolvePath(filepath: String): DocumentsNode? {
         val tokens = StringTokenizer(filepath, File.separator, false)
         var iterator = root

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/FileUtil.kt

@@ -144,7 +144,7 @@ object FileUtil {
      * @param path Native content uri path
      * @return bool
      */
-    fun exists(path: String?): Boolean {
+    fun exists(path: String?, suppressLog: Boolean = false): Boolean {
         var c: Cursor? = null
         try {
             val mUri = Uri.parse(path)
@@ -152,7 +152,9 @@ object FileUtil {
             c = context.contentResolver.query(mUri, columns, null, null, null)
             return c!!.count > 0
         } catch (e: Exception) {
-            Log.info("[FileUtil] Cannot find file from given path, error: " + e.message)
+            if (!suppressLog) {
+                Log.info("[FileUtil] Cannot find file from given path, error: " + e.message)
+            }
         } finally {
             closeQuietly(c)
         }

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameHelper.kt

@@ -71,27 +71,26 @@ object GameHelper {
 
     fun getGame(uri: Uri, addedToLibrary: Boolean): Game {
         val filePath = uri.toString()
-        var name = NativeLibrary.getTitle(filePath)
+        var name = GameMetadata.getTitle(filePath)
 
         // If the game's title field is empty, use the filename.
         if (name.isEmpty()) {
             name = FileUtil.getFilename(uri)
         }
-        var gameId = NativeLibrary.getGameId(filePath)
+        var programId = GameMetadata.getProgramId(filePath)
 
         // If the game's ID field is empty, use the filename without extension.
-        if (gameId.isEmpty()) {
-            gameId = name.substring(0, name.lastIndexOf("."))
+        if (programId.isEmpty()) {
+            programId = name.substring(0, name.lastIndexOf("."))
         }
 
         val newGame = Game(
             name,
-            NativeLibrary.getDescription(filePath).replace("\n", " "),
-            NativeLibrary.getRegions(filePath),
             filePath,
-            gameId,
-            NativeLibrary.getCompany(filePath),
-            NativeLibrary.isHomebrew(filePath)
+            programId,
+            GameMetadata.getDeveloper(filePath),
+            GameMetadata.getVersion(filePath),
+            GameMetadata.getIsHomebrew(filePath)
         )
 
         if (addedToLibrary) {

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameIconUtils.kt

@@ -18,7 +18,6 @@ import coil.key.Keyer
 import coil.memory.MemoryCache
 import coil.request.ImageRequest
 import coil.request.Options
-import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
 import org.yuzu.yuzu_emu.model.Game
@@ -36,7 +35,7 @@ class GameIconFetcher(
     }
 
     private fun decodeGameIcon(uri: String): Bitmap? {
-        val data = NativeLibrary.getIcon(uri)
+        val data = GameMetadata.getIcon(uri)
         return BitmapFactory.decodeByteArray(
             data,
             0,

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameMetadata.kt

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package org.yuzu.yuzu_emu.utils
+
+object GameMetadata {
+    external fun getTitle(path: String): String
+
+    external fun getProgramId(path: String): String
+
+    external fun getDeveloper(path: String): String
+
+    external fun getVersion(path: String): String
+
+    external fun getIcon(path: String): ByteArray
+
+    external fun getIsHomebrew(path: String): Boolean
+
+    external fun resetMetadata()
+}

src/android/app/src/main/jni/CMakeLists.txt

@@ -14,8 +14,10 @@ add_library(yuzu-android SHARED
     id_cache.cpp
     id_cache.h
     native.cpp
+    native.h
     native_config.cpp
     uisettings.cpp
+    game_metadata.cpp
 )
 
 set_property(TARGET yuzu-android PROPERTY IMPORTED_LOCATION ${FFmpeg_LIBRARY_DIR})

src/android/app/src/main/jni/game_metadata.cpp

@@ -0,0 +1,112 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <core/core.h>
+#include <core/file_sys/patch_manager.h>
+#include <core/loader/nro.h>
+#include <jni.h>
+#include "core/loader/loader.h"
+#include "jni/android_common/android_common.h"
+#include "native.h"
+
+struct RomMetadata {
+    std::string title;
+    u64 programId;
+    std::string developer;
+    std::string version;
+    std::vector<u8> icon;
+    bool isHomebrew;
+};
+
+std::unordered_map<std::string, RomMetadata> m_rom_metadata_cache;
+
+RomMetadata CacheRomMetadata(const std::string& path) {
+    const auto file =
+        Core::GetGameFileFromPath(EmulationSession::GetInstance().System().GetFilesystem(), path);
+    auto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file, 0, 0);
+
+    RomMetadata entry;
+    loader->ReadTitle(entry.title);
+    loader->ReadProgramId(entry.programId);
+    loader->ReadIcon(entry.icon);
+
+    const FileSys::PatchManager pm{
+        entry.programId, EmulationSession::GetInstance().System().GetFileSystemController(),
+        EmulationSession::GetInstance().System().GetContentProvider()};
+    const auto control = pm.GetControlMetadata();
+
+    if (control.first != nullptr) {
+        entry.developer = control.first->GetDeveloperName();
+        entry.version = control.first->GetVersionString();
+    } else {
+        FileSys::NACP nacp;
+        if (loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
+            entry.developer = nacp.GetDeveloperName();
+        } else {
+            entry.developer = "";
+        }
+
+        entry.version = "1.0.0";
+    }
+
+    if (loader->GetFileType() == Loader::FileType::NRO) {
+        auto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
+        entry.isHomebrew = loader_nro->IsHomebrew();
+    } else {
+        entry.isHomebrew = false;
+    }
+
+    m_rom_metadata_cache[path] = entry;
+
+    return entry;
+}
+
+RomMetadata GetRomMetadata(const std::string& path) {
+    if (auto search = m_rom_metadata_cache.find(path); search != m_rom_metadata_cache.end()) {
+        return search->second;
+    }
+
+    return CacheRomMetadata(path);
+}
+
+extern "C" {
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getTitle(JNIEnv* env, jobject obj,
+                                                            jstring jpath) {
+    return ToJString(env, GetRomMetadata(GetJString(env, jpath)).title);
+}
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getProgramId(JNIEnv* env, jobject obj,
+                                                                jstring jpath) {
+    return ToJString(env, std::to_string(GetRomMetadata(GetJString(env, jpath)).programId));
+}
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getDeveloper(JNIEnv* env, jobject obj,
+                                                                jstring jpath) {
+    return ToJString(env, GetRomMetadata(GetJString(env, jpath)).developer);
+}
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getVersion(JNIEnv* env, jobject obj,
+                                                              jstring jpath) {
+    return ToJString(env, GetRomMetadata(GetJString(env, jpath)).version);
+}
+
+jbyteArray Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIcon(JNIEnv* env, jobject obj,
+                                                              jstring jpath) {
+    auto icon_data = GetRomMetadata(GetJString(env, jpath)).icon;
+    jbyteArray icon = env->NewByteArray(static_cast<jsize>(icon_data.size()));
+    env->SetByteArrayRegion(icon, 0, env->GetArrayLength(icon),
+                            reinterpret_cast<jbyte*>(icon_data.data()));
+    return icon;
+}
+
+jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsHomebrew(JNIEnv* env, jobject obj,
+                                                                  jstring jpath) {
+    return static_cast<jboolean>(GetRomMetadata(GetJString(env, jpath)).isHomebrew);
+}
+
+void Java_org_yuzu_yuzu_1emu_utils_GameMetadata_resetMetadata(JNIEnv* env, jobject obj) {
+    return m_rom_metadata_cache.clear();
+}
+
+} // extern "C"

src/android/app/src/main/jni/native.cpp

@@ -33,7 +33,6 @@
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/submission_package.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_real.h"
@@ -48,514 +47,416 @@
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "core/hid/hid_types.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
-#include "core/perf_stats.h"
 #include "jni/android_common/android_common.h"
-#include "jni/applets/software_keyboard.h"
 #include "jni/config.h"
-#include "jni/emu_window/emu_window.h"
 #include "jni/id_cache.h"
-#include "video_core/rasterizer_interface.h"
+#include "jni/native.h"
 #include "video_core/renderer_base.h"
 
 #define jconst [[maybe_unused]] const auto
 #define jauto [[maybe_unused]] auto
 
-namespace {
+static EmulationSession s_instance;
 
-class EmulationSession final {
-public:
-    EmulationSession() {
-        m_vfs = std::make_shared<FileSys::RealVfsFilesystem>();
-    }
+EmulationSession::EmulationSession() {
+    m_vfs = std::make_shared<FileSys::RealVfsFilesystem>();
+}
 
-    ~EmulationSession() = default;
+EmulationSession& EmulationSession::GetInstance() {
+    return s_instance;
+}
 
-    static EmulationSession& GetInstance() {
-        return s_instance;
-    }
+const Core::System& EmulationSession::System() const {
+    return m_system;
+}
 
-    const Core::System& System() const {
-        return m_system;
-    }
+Core::System& EmulationSession::System() {
+    return m_system;
+}
 
-    Core::System& System() {
-        return m_system;
-    }
+const EmuWindow_Android& EmulationSession::Window() const {
+    return *m_window;
+}
 
-    const EmuWindow_Android& Window() const {
-        return *m_window;
-    }
+EmuWindow_Android& EmulationSession::Window() {
+    return *m_window;
+}
 
-    EmuWindow_Android& Window() {
-        return *m_window;
-    }
+ANativeWindow* EmulationSession::NativeWindow() const {
+    return m_native_window;
+}
 
-    ANativeWindow* NativeWindow() const {
-        return m_native_window;
-    }
+void EmulationSession::SetNativeWindow(ANativeWindow* native_window) {
+    m_native_window = native_window;
+}
 
-    void SetNativeWindow(ANativeWindow* native_window) {
-        m_native_window = native_window;
-    }
-
-    int InstallFileToNand(std::string filename, std::string file_extension) {
-        jconst copy_func = [](const FileSys::VirtualFile& src, const FileSys::VirtualFile& dest,
-                              std::size_t block_size) {
-            if (src == nullptr || dest == nullptr) {
-                return false;
-            }
-            if (!dest->Resize(src->GetSize())) {
-                return false;
-            }
-
-            using namespace Common::Literals;
-            [[maybe_unused]] std::vector<u8> buffer(1_MiB);
-
-            for (std::size_t i = 0; i < src->GetSize(); i += buffer.size()) {
-                jconst read = src->Read(buffer.data(), buffer.size(), i);
-                dest->Write(buffer.data(), read, i);
-            }
-            return true;
-        };
-
-        enum InstallResult {
-            Success = 0,
-            SuccessFileOverwritten = 1,
-            InstallError = 2,
-            ErrorBaseGame = 3,
-            ErrorFilenameExtension = 4,
-        };
-
-        m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-        m_system.GetFileSystemController().CreateFactories(*m_vfs);
-
-        [[maybe_unused]] std::shared_ptr<FileSys::NSP> nsp;
-        if (file_extension == "nsp") {
-            nsp = std::make_shared<FileSys::NSP>(m_vfs->OpenFile(filename, FileSys::Mode::Read));
-            if (nsp->IsExtractedType()) {
-                return InstallError;
-            }
-        } else {
-            return ErrorFilenameExtension;
+int EmulationSession::InstallFileToNand(std::string filename, std::string file_extension) {
+    jconst copy_func = [](const FileSys::VirtualFile& src, const FileSys::VirtualFile& dest,
+                          std::size_t block_size) {
+        if (src == nullptr || dest == nullptr) {
+            return false;
         }
-
-        if (!nsp) {
-            return InstallError;
-        }
-
-        if (nsp->GetStatus() != Loader::ResultStatus::Success) {
-            return InstallError;
-        }
-
-        jconst res = m_system.GetFileSystemController().GetUserNANDContents()->InstallEntry(
-            *nsp, true, copy_func);
-
-        switch (res) {
-        case FileSys::InstallResult::Success:
-            return Success;
-        case FileSys::InstallResult::OverwriteExisting:
-            return SuccessFileOverwritten;
-        case FileSys::InstallResult::ErrorBaseInstall:
-            return ErrorBaseGame;
-        default:
-            return InstallError;
-        }
-    }
-
-    void InitializeGpuDriver(const std::string& hook_lib_dir, const std::string& custom_driver_dir,
-                             const std::string& custom_driver_name,
-                             const std::string& file_redirect_dir) {
-#ifdef ARCHITECTURE_arm64
-        void* handle{};
-        const char* file_redirect_dir_{};
-        int featureFlags{};
-
-        // Enable driver file redirection when renderer debugging is enabled.
-        if (Settings::values.renderer_debug && file_redirect_dir.size()) {
-            featureFlags |= ADRENOTOOLS_DRIVER_FILE_REDIRECT;
-            file_redirect_dir_ = file_redirect_dir.c_str();
-        }
-
-        // Try to load a custom driver.
-        if (custom_driver_name.size()) {
-            handle = adrenotools_open_libvulkan(
-                RTLD_NOW, featureFlags | ADRENOTOOLS_DRIVER_CUSTOM, nullptr, hook_lib_dir.c_str(),
-                custom_driver_dir.c_str(), custom_driver_name.c_str(), file_redirect_dir_, nullptr);
-        }
-
-        // Try to load the system driver.
-        if (!handle) {
-            handle =
-                adrenotools_open_libvulkan(RTLD_NOW, featureFlags, nullptr, hook_lib_dir.c_str(),
-                                           nullptr, nullptr, file_redirect_dir_, nullptr);
-        }
-
-        m_vulkan_library = std::make_shared<Common::DynamicLibrary>(handle);
-#endif
-    }
-
-    bool IsRunning() const {
-        return m_is_running;
-    }
-
-    bool IsPaused() const {
-        return m_is_running && m_is_paused;
-    }
-
-    const Core::PerfStatsResults& PerfStats() const {
-        std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
-        return m_perf_stats;
-    }
-
-    void SurfaceChanged() {
-        if (!IsRunning()) {
-            return;
-        }
-        m_window->OnSurfaceChanged(m_native_window);
-    }
-
-    void ConfigureFilesystemProvider(const std::string& filepath) {
-        const auto file = m_system.GetFilesystem()->OpenFile(filepath, FileSys::Mode::Read);
-        if (!file) {
-            return;
-        }
-
-        auto loader = Loader::GetLoader(m_system, file);
-        if (!loader) {
-            return;
-        }
-
-        const auto file_type = loader->GetFileType();
-        if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error) {
-            return;
-        }
-
-        u64 program_id = 0;
-        const auto res2 = loader->ReadProgramId(program_id);
-        if (res2 == Loader::ResultStatus::Success && file_type == Loader::FileType::NCA) {
-            m_manual_provider->AddEntry(FileSys::TitleType::Application,
-                                        FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()),
-                                        program_id, file);
-        } else if (res2 == Loader::ResultStatus::Success &&
-                   (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP)) {
-            const auto nsp = file_type == Loader::FileType::NSP
-                                 ? std::make_shared<FileSys::NSP>(file)
-                                 : FileSys::XCI{file}.GetSecurePartitionNSP();
-            for (const auto& title : nsp->GetNCAs()) {
-                for (const auto& entry : title.second) {
-                    m_manual_provider->AddEntry(entry.first.first, entry.first.second, title.first,
-                                                entry.second->GetBaseFile());
-                }
-            }
-        }
-    }
-
-    Core::SystemResultStatus InitializeEmulation(const std::string& filepath) {
-        std::scoped_lock lock(m_mutex);
-
-        // Create the render window.
-        m_window = std::make_unique<EmuWindow_Android>(&m_input_subsystem, m_native_window,
-                                                       m_vulkan_library);
-
-        m_system.SetFilesystem(m_vfs);
-        m_system.GetUserChannel().clear();
-
-        // Initialize system.
-        jauto android_keyboard = std::make_unique<SoftwareKeyboard::AndroidKeyboard>();
-        m_software_keyboard = android_keyboard.get();
-        m_system.SetShuttingDown(false);
-        m_system.ApplySettings();
-        Settings::LogSettings();
-        m_system.HIDCore().ReloadInputDevices();
-        m_system.SetAppletFrontendSet({
-            nullptr,                     // Amiibo Settings
-            nullptr,                     // Controller Selector
-            nullptr,                     // Error Display
-            nullptr,                     // Mii Editor
-            nullptr,                     // Parental Controls
-            nullptr,                     // Photo Viewer
-            nullptr,                     // Profile Selector
-            std::move(android_keyboard), // Software Keyboard
-            nullptr,                     // Web Browser
-        });
-
-        // Initialize filesystem.
-        m_manual_provider = std::make_unique<FileSys::ManualContentProvider>();
-        m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-        m_system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual,
-                                         m_manual_provider.get());
-        m_system.GetFileSystemController().CreateFactories(*m_vfs);
-        ConfigureFilesystemProvider(filepath);
-
-        // Initialize account manager
-        m_profile_manager = std::make_unique<Service::Account::ProfileManager>();
-
-        // Load the ROM.
-        m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filepath);
-        if (m_load_result != Core::SystemResultStatus::Success) {
-            return m_load_result;
-        }
-
-        // Complete initialization.
-        m_system.GPU().Start();
-        m_system.GetCpuManager().OnGpuReady();
-        m_system.RegisterExitCallback([&] { HaltEmulation(); });
-
-        return Core::SystemResultStatus::Success;
-    }
-
-    void ShutdownEmulation() {
-        std::scoped_lock lock(m_mutex);
-
-        m_is_running = false;
-
-        // Unload user input.
-        m_system.HIDCore().UnloadInputDevices();
-
-        // Shutdown the main emulated process
-        if (m_load_result == Core::SystemResultStatus::Success) {
-            m_system.DetachDebugger();
-            m_system.ShutdownMainProcess();
-            m_detached_tasks.WaitForAllTasks();
-            m_load_result = Core::SystemResultStatus::ErrorNotInitialized;
-            m_window.reset();
-            OnEmulationStopped(Core::SystemResultStatus::Success);
-            return;
-        }
-
-        // Tear down the render window.
-        m_window.reset();
-    }
-
-    void PauseEmulation() {
-        std::scoped_lock lock(m_mutex);
-        m_system.Pause();
-        m_is_paused = true;
-    }
-
-    void UnPauseEmulation() {
-        std::scoped_lock lock(m_mutex);
-        m_system.Run();
-        m_is_paused = false;
-    }
-
-    void HaltEmulation() {
-        std::scoped_lock lock(m_mutex);
-        m_is_running = false;
-        m_cv.notify_one();
-    }
-
-    void RunEmulation() {
-        {
-            std::scoped_lock lock(m_mutex);
-            m_is_running = true;
-        }
-
-        // Load the disk shader cache.
-        if (Settings::values.use_disk_shader_cache.GetValue()) {
-            LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
-            m_system.Renderer().ReadRasterizer()->LoadDiskResources(
-                m_system.GetApplicationProcessProgramID(), std::stop_token{},
-                LoadDiskCacheProgress);
-            LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
-        }
-
-        void(m_system.Run());
-
-        if (m_system.DebuggerEnabled()) {
-            m_system.InitializeDebugger();
-        }
-
-        OnEmulationStarted();
-
-        while (true) {
-            {
-                [[maybe_unused]] std::unique_lock lock(m_mutex);
-                if (m_cv.wait_for(lock, std::chrono::milliseconds(800),
-                                  [&]() { return !m_is_running; })) {
-                    // Emulation halted.
-                    break;
-                }
-            }
-            {
-                // Refresh performance stats.
-                std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
-                m_perf_stats = m_system.GetAndResetPerfStats();
-            }
-        }
-    }
-
-    std::string GetRomTitle(const std::string& path) {
-        return GetRomMetadata(path).title;
-    }
-
-    std::vector<u8> GetRomIcon(const std::string& path) {
-        return GetRomMetadata(path).icon;
-    }
-
-    bool GetIsHomebrew(const std::string& path) {
-        return GetRomMetadata(path).isHomebrew;
-    }
-
-    void ResetRomMetadata() {
-        m_rom_metadata_cache.clear();
-    }
-
-    bool IsHandheldOnly() {
-        jconst npad_style_set = m_system.HIDCore().GetSupportedStyleTag();
-
-        if (npad_style_set.fullkey == 1) {
+        if (!dest->Resize(src->GetSize())) {
             return false;
         }
 
-        if (npad_style_set.handheld == 0) {
-            return false;
+        using namespace Common::Literals;
+        [[maybe_unused]] std::vector<u8> buffer(1_MiB);
+
+        for (std::size_t i = 0; i < src->GetSize(); i += buffer.size()) {
+            jconst read = src->Read(buffer.data(), buffer.size(), i);
+            dest->Write(buffer.data(), read, i);
         }
-
-        return !Settings::IsDockedMode();
-    }
-
-    void SetDeviceType([[maybe_unused]] int index, int type) {
-        jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
-        controller->SetNpadStyleIndex(static_cast<Core::HID::NpadStyleIndex>(type));
-    }
-
-    void OnGamepadConnectEvent([[maybe_unused]] int index) {
-        jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
-
-        // Ensure that player1 is configured correctly and handheld disconnected
-        if (controller->GetNpadIdType() == Core::HID::NpadIdType::Player1) {
-            jauto handheld =
-                m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
-
-            if (controller->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::Handheld) {
-                handheld->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
-                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
-                handheld->Disconnect();
-            }
-        }
-
-        // Ensure that handheld is configured correctly and player 1 disconnected
-        if (controller->GetNpadIdType() == Core::HID::NpadIdType::Handheld) {
-            jauto player1 =
-                m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
-
-            if (controller->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::Handheld) {
-                player1->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
-                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
-                player1->Disconnect();
-            }
-        }
-
-        if (!controller->IsConnected()) {
-            controller->Connect();
-        }
-    }
-
-    void OnGamepadDisconnectEvent([[maybe_unused]] int index) {
-        jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
-        controller->Disconnect();
-    }
-
-    SoftwareKeyboard::AndroidKeyboard* SoftwareKeyboard() {
-        return m_software_keyboard;
-    }
-
-private:
-    struct RomMetadata {
-        std::string title;
-        std::vector<u8> icon;
-        bool isHomebrew;
+        return true;
     };
 
-    RomMetadata GetRomMetadata(const std::string& path) {
-        if (jauto search = m_rom_metadata_cache.find(path); search != m_rom_metadata_cache.end()) {
-            return search->second;
+    enum InstallResult {
+        Success = 0,
+        SuccessFileOverwritten = 1,
+        InstallError = 2,
+        ErrorBaseGame = 3,
+        ErrorFilenameExtension = 4,
+    };
+
+    m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    m_system.GetFileSystemController().CreateFactories(*m_vfs);
+
+    [[maybe_unused]] std::shared_ptr<FileSys::NSP> nsp;
+    if (file_extension == "nsp") {
+        nsp = std::make_shared<FileSys::NSP>(m_vfs->OpenFile(filename, FileSys::Mode::Read));
+        if (nsp->IsExtractedType()) {
+            return InstallError;
         }
-
-        return CacheRomMetadata(path);
+    } else {
+        return ErrorFilenameExtension;
     }
 
-    RomMetadata CacheRomMetadata(const std::string& path) {
-        jconst file = Core::GetGameFileFromPath(m_vfs, path);
-        jauto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file, 0, 0);
+    if (!nsp) {
+        return InstallError;
+    }
 
-        RomMetadata entry;
-        loader->ReadTitle(entry.title);
-        loader->ReadIcon(entry.icon);
-        if (loader->GetFileType() == Loader::FileType::NRO) {
-            jauto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
-            entry.isHomebrew = loader_nro->IsHomebrew();
-        } else {
-            entry.isHomebrew = false;
+    if (nsp->GetStatus() != Loader::ResultStatus::Success) {
+        return InstallError;
+    }
+
+    jconst res = m_system.GetFileSystemController().GetUserNANDContents()->InstallEntry(*nsp, true,
+                                                                                        copy_func);
+
+    switch (res) {
+    case FileSys::InstallResult::Success:
+        return Success;
+    case FileSys::InstallResult::OverwriteExisting:
+        return SuccessFileOverwritten;
+    case FileSys::InstallResult::ErrorBaseInstall:
+        return ErrorBaseGame;
+    default:
+        return InstallError;
+    }
+}
+
+void EmulationSession::InitializeGpuDriver(const std::string& hook_lib_dir,
+                                           const std::string& custom_driver_dir,
+                                           const std::string& custom_driver_name,
+                                           const std::string& file_redirect_dir) {
+#ifdef ARCHITECTURE_arm64
+    void* handle{};
+    const char* file_redirect_dir_{};
+    int featureFlags{};
+
+    // Enable driver file redirection when renderer debugging is enabled.
+    if (Settings::values.renderer_debug && file_redirect_dir.size()) {
+        featureFlags |= ADRENOTOOLS_DRIVER_FILE_REDIRECT;
+        file_redirect_dir_ = file_redirect_dir.c_str();
+    }
+
+    // Try to load a custom driver.
+    if (custom_driver_name.size()) {
+        handle = adrenotools_open_libvulkan(
+            RTLD_NOW, featureFlags | ADRENOTOOLS_DRIVER_CUSTOM, nullptr, hook_lib_dir.c_str(),
+            custom_driver_dir.c_str(), custom_driver_name.c_str(), file_redirect_dir_, nullptr);
+    }
+
+    // Try to load the system driver.
+    if (!handle) {
+        handle = adrenotools_open_libvulkan(RTLD_NOW, featureFlags, nullptr, hook_lib_dir.c_str(),
+                                            nullptr, nullptr, file_redirect_dir_, nullptr);
+    }
+
+    m_vulkan_library = std::make_shared<Common::DynamicLibrary>(handle);
+#endif
+}
+
+bool EmulationSession::IsRunning() const {
+    return m_is_running;
+}
+
+bool EmulationSession::IsPaused() const {
+    return m_is_running && m_is_paused;
+}
+
+const Core::PerfStatsResults& EmulationSession::PerfStats() const {
+    std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
+    return m_perf_stats;
+}
+
+void EmulationSession::SurfaceChanged() {
+    if (!IsRunning()) {
+        return;
+    }
+    m_window->OnSurfaceChanged(m_native_window);
+}
+
+void EmulationSession::ConfigureFilesystemProvider(const std::string& filepath) {
+    const auto file = m_system.GetFilesystem()->OpenFile(filepath, FileSys::Mode::Read);
+    if (!file) {
+        return;
+    }
+
+    auto loader = Loader::GetLoader(m_system, file);
+    if (!loader) {
+        return;
+    }
+
+    const auto file_type = loader->GetFileType();
+    if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error) {
+        return;
+    }
+
+    u64 program_id = 0;
+    const auto res2 = loader->ReadProgramId(program_id);
+    if (res2 == Loader::ResultStatus::Success && file_type == Loader::FileType::NCA) {
+        m_manual_provider->AddEntry(FileSys::TitleType::Application,
+                                    FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()),
+                                    program_id, file);
+    } else if (res2 == Loader::ResultStatus::Success &&
+               (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP)) {
+        const auto nsp = file_type == Loader::FileType::NSP
+                             ? std::make_shared<FileSys::NSP>(file)
+                             : FileSys::XCI{file}.GetSecurePartitionNSP();
+        for (const auto& title : nsp->GetNCAs()) {
+            for (const auto& entry : title.second) {
+                m_manual_provider->AddEntry(entry.first.first, entry.first.second, title.first,
+                                            entry.second->GetBaseFile());
+            }
         }
+    }
+}
 
-        m_rom_metadata_cache[path] = entry;
+Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string& filepath) {
+    std::scoped_lock lock(m_mutex);
 
-        return entry;
+    // Create the render window.
+    m_window =
+        std::make_unique<EmuWindow_Android>(&m_input_subsystem, m_native_window, m_vulkan_library);
+
+    m_system.SetFilesystem(m_vfs);
+    m_system.GetUserChannel().clear();
+
+    // Initialize system.
+    jauto android_keyboard = std::make_unique<SoftwareKeyboard::AndroidKeyboard>();
+    m_software_keyboard = android_keyboard.get();
+    m_system.SetShuttingDown(false);
+    m_system.ApplySettings();
+    Settings::LogSettings();
+    m_system.HIDCore().ReloadInputDevices();
+    m_system.SetAppletFrontendSet({
+        nullptr,                     // Amiibo Settings
+        nullptr,                     // Controller Selector
+        nullptr,                     // Error Display
+        nullptr,                     // Mii Editor
+        nullptr,                     // Parental Controls
+        nullptr,                     // Photo Viewer
+        nullptr,                     // Profile Selector
+        std::move(android_keyboard), // Software Keyboard
+        nullptr,                     // Web Browser
+    });
+
+    // Initialize filesystem.
+    m_manual_provider = std::make_unique<FileSys::ManualContentProvider>();
+    m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    m_system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual,
+                                     m_manual_provider.get());
+    m_system.GetFileSystemController().CreateFactories(*m_vfs);
+    ConfigureFilesystemProvider(filepath);
+
+    // Initialize account manager
+    m_profile_manager = std::make_unique<Service::Account::ProfileManager>();
+
+    // Load the ROM.
+    m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filepath);
+    if (m_load_result != Core::SystemResultStatus::Success) {
+        return m_load_result;
     }
 
-private:
-    static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max) {
-        JNIEnv* env = IDCache::GetEnvForThread();
-        env->CallStaticVoidMethod(IDCache::GetDiskCacheProgressClass(),
-                                  IDCache::GetDiskCacheLoadProgress(), static_cast<jint>(stage),
-                                  static_cast<jint>(progress), static_cast<jint>(max));
+    // Complete initialization.
+    m_system.GPU().Start();
+    m_system.GetCpuManager().OnGpuReady();
+    m_system.RegisterExitCallback([&] { HaltEmulation(); });
+
+    return Core::SystemResultStatus::Success;
+}
+
+void EmulationSession::ShutdownEmulation() {
+    std::scoped_lock lock(m_mutex);
+
+    m_is_running = false;
+
+    // Unload user input.
+    m_system.HIDCore().UnloadInputDevices();
+
+    // Shutdown the main emulated process
+    if (m_load_result == Core::SystemResultStatus::Success) {
+        m_system.DetachDebugger();
+        m_system.ShutdownMainProcess();
+        m_detached_tasks.WaitForAllTasks();
+        m_load_result = Core::SystemResultStatus::ErrorNotInitialized;
+        m_window.reset();
+        OnEmulationStopped(Core::SystemResultStatus::Success);
+        return;
     }
 
-    static void OnEmulationStarted() {
-        JNIEnv* env = IDCache::GetEnvForThread();
-        env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(),
-                                  IDCache::GetOnEmulationStarted());
+    // Tear down the render window.
+    m_window.reset();
+}
+
+void EmulationSession::PauseEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_system.Pause();
+    m_is_paused = true;
+}
+
+void EmulationSession::UnPauseEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_system.Run();
+    m_is_paused = false;
+}
+
+void EmulationSession::HaltEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_is_running = false;
+    m_cv.notify_one();
+}
+
+void EmulationSession::RunEmulation() {
+    {
+        std::scoped_lock lock(m_mutex);
+        m_is_running = true;
     }
 
-    static void OnEmulationStopped(Core::SystemResultStatus result) {
-        JNIEnv* env = IDCache::GetEnvForThread();
-        env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(),
-                                  IDCache::GetOnEmulationStopped(), static_cast<jint>(result));
+    // Load the disk shader cache.
+    if (Settings::values.use_disk_shader_cache.GetValue()) {
+        LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
+        m_system.Renderer().ReadRasterizer()->LoadDiskResources(
+            m_system.GetApplicationProcessProgramID(), std::stop_token{}, LoadDiskCacheProgress);
+        LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
     }
 
-private:
-    static EmulationSession s_instance;
+    void(m_system.Run());
 
-    // Frontend management
-    std::unordered_map<std::string, RomMetadata> m_rom_metadata_cache;
+    if (m_system.DebuggerEnabled()) {
+        m_system.InitializeDebugger();
+    }
 
-    // Window management
-    std::unique_ptr<EmuWindow_Android> m_window;
-    ANativeWindow* m_native_window{};
+    OnEmulationStarted();
 
-    // Core emulation
-    Core::System m_system;
-    InputCommon::InputSubsystem m_input_subsystem;
-    Common::DetachedTasks m_detached_tasks;
-    Core::PerfStatsResults m_perf_stats{};
-    std::shared_ptr<FileSys::VfsFilesystem> m_vfs;
-    Core::SystemResultStatus m_load_result{Core::SystemResultStatus::ErrorNotInitialized};
-    std::atomic<bool> m_is_running = false;
-    std::atomic<bool> m_is_paused = false;
-    SoftwareKeyboard::AndroidKeyboard* m_software_keyboard{};
-    std::unique_ptr<Service::Account::ProfileManager> m_profile_manager;
-    std::unique_ptr<FileSys::ManualContentProvider> m_manual_provider;
+    while (true) {
+        {
+            [[maybe_unused]] std::unique_lock lock(m_mutex);
+            if (m_cv.wait_for(lock, std::chrono::milliseconds(800),
+                              [&]() { return !m_is_running; })) {
+                // Emulation halted.
+                break;
+            }
+        }
+        {
+            // Refresh performance stats.
+            std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
+            m_perf_stats = m_system.GetAndResetPerfStats();
+        }
+    }
+}
 
-    // GPU driver parameters
-    std::shared_ptr<Common::DynamicLibrary> m_vulkan_library;
+bool EmulationSession::IsHandheldOnly() {
+    jconst npad_style_set = m_system.HIDCore().GetSupportedStyleTag();
 
-    // Synchronization
-    std::condition_variable_any m_cv;
-    mutable std::mutex m_perf_stats_mutex;
-    mutable std::mutex m_mutex;
-};
+    if (npad_style_set.fullkey == 1) {
+        return false;
+    }
 
-/*static*/ EmulationSession EmulationSession::s_instance;
+    if (npad_style_set.handheld == 0) {
+        return false;
+    }
 
-} // Anonymous namespace
+    return !Settings::IsDockedMode();
+}
+
+void EmulationSession::SetDeviceType([[maybe_unused]] int index, int type) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+    controller->SetNpadStyleIndex(static_cast<Core::HID::NpadStyleIndex>(type));
+}
+
+void EmulationSession::OnGamepadConnectEvent([[maybe_unused]] int index) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+
+    // Ensure that player1 is configured correctly and handheld disconnected
+    if (controller->GetNpadIdType() == Core::HID::NpadIdType::Player1) {
+        jauto handheld = m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+
+        if (controller->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::Handheld) {
+            handheld->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
+            handheld->Disconnect();
+        }
+    }
+
+    // Ensure that handheld is configured correctly and player 1 disconnected
+    if (controller->GetNpadIdType() == Core::HID::NpadIdType::Handheld) {
+        jauto player1 = m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
+
+        if (controller->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::Handheld) {
+            player1->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
+            player1->Disconnect();
+        }
+    }
+
+    if (!controller->IsConnected()) {
+        controller->Connect();
+    }
+}
+
+void EmulationSession::OnGamepadDisconnectEvent([[maybe_unused]] int index) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+    controller->Disconnect();
+}
+
+SoftwareKeyboard::AndroidKeyboard* EmulationSession::SoftwareKeyboard() {
+    return m_software_keyboard;
+}
+
+void EmulationSession::LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress,
+                                             int max) {
+    JNIEnv* env = IDCache::GetEnvForThread();
+    env->CallStaticVoidMethod(IDCache::GetDiskCacheProgressClass(),
+                              IDCache::GetDiskCacheLoadProgress(), static_cast<jint>(stage),
+                              static_cast<jint>(progress), static_cast<jint>(max));
+}
+
+void EmulationSession::OnEmulationStarted() {
+    JNIEnv* env = IDCache::GetEnvForThread();
+    env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(), IDCache::GetOnEmulationStarted());
+}
+
+void EmulationSession::OnEmulationStopped(Core::SystemResultStatus result) {
+    JNIEnv* env = IDCache::GetEnvForThread();
+    env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(), IDCache::GetOnEmulationStopped(),
+                              static_cast<jint>(result));
+}
 
 static Core::SystemResultStatus RunEmulation(const std::string& filepath) {
     Common::Log::Initialize();
@@ -657,10 +558,6 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_stopEmulation(JNIEnv* env, jclass cla
     EmulationSession::GetInstance().HaltEmulation();
 }
 
-void Java_org_yuzu_yuzu_1emu_NativeLibrary_resetRomMetadata(JNIEnv* env, jclass clazz) {
-    EmulationSession::GetInstance().ResetRomMetadata();
-}
-
 jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_isRunning(JNIEnv* env, jclass clazz) {
     return static_cast<jboolean>(EmulationSession::GetInstance().IsRunning());
 }
@@ -766,46 +663,6 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_onTouchReleased(JNIEnv* env, jclass c
     }
 }
 
-jbyteArray Java_org_yuzu_yuzu_1emu_NativeLibrary_getIcon(JNIEnv* env, jclass clazz,
-                                                         jstring j_filename) {
-    jauto icon_data = EmulationSession::GetInstance().GetRomIcon(GetJString(env, j_filename));
-    jbyteArray icon = env->NewByteArray(static_cast<jsize>(icon_data.size()));
-    env->SetByteArrayRegion(icon, 0, env->GetArrayLength(icon),
-                            reinterpret_cast<jbyte*>(icon_data.data()));
-    return icon;
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getTitle(JNIEnv* env, jclass clazz,
-                                                       jstring j_filename) {
-    jauto title = EmulationSession::GetInstance().GetRomTitle(GetJString(env, j_filename));
-    return env->NewStringUTF(title.c_str());
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getDescription(JNIEnv* env, jclass clazz,
-                                                             jstring j_filename) {
-    return j_filename;
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getGameId(JNIEnv* env, jclass clazz,
-                                                        jstring j_filename) {
-    return j_filename;
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getRegions(JNIEnv* env, jclass clazz,
-                                                         jstring j_filename) {
-    return env->NewStringUTF("");
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getCompany(JNIEnv* env, jclass clazz,
-                                                         jstring j_filename) {
-    return env->NewStringUTF("");
-}
-
-jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_isHomebrew(JNIEnv* env, jclass clazz,
-                                                          jstring j_filename) {
-    return EmulationSession::GetInstance().GetIsHomebrew(GetJString(env, j_filename));
-}
-
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_initializeEmulation(JNIEnv* env, jclass clazz) {
     // Create the default config.ini.
     Config{};

src/android/app/src/main/jni/native.h

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <android/native_window_jni.h>
+#include "common/detached_tasks.h"
+#include "core/core.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/perf_stats.h"
+#include "jni/applets/software_keyboard.h"
+#include "jni/emu_window/emu_window.h"
+#include "video_core/rasterizer_interface.h"
+
+#pragma once
+
+class EmulationSession final {
+public:
+    explicit EmulationSession();
+    ~EmulationSession() = default;
+
+    static EmulationSession& GetInstance();
+    const Core::System& System() const;
+    Core::System& System();
+
+    const EmuWindow_Android& Window() const;
+    EmuWindow_Android& Window();
+    ANativeWindow* NativeWindow() const;
+    void SetNativeWindow(ANativeWindow* native_window);
+    void SurfaceChanged();
+
+    int InstallFileToNand(std::string filename, std::string file_extension);
+    void InitializeGpuDriver(const std::string& hook_lib_dir, const std::string& custom_driver_dir,
+                             const std::string& custom_driver_name,
+                             const std::string& file_redirect_dir);
+
+    bool IsRunning() const;
+    bool IsPaused() const;
+    void PauseEmulation();
+    void UnPauseEmulation();
+    void HaltEmulation();
+    void RunEmulation();
+    void ShutdownEmulation();
+
+    const Core::PerfStatsResults& PerfStats() const;
+    void ConfigureFilesystemProvider(const std::string& filepath);
+    Core::SystemResultStatus InitializeEmulation(const std::string& filepath);
+
+    bool IsHandheldOnly();
+    void SetDeviceType([[maybe_unused]] int index, int type);
+    void OnGamepadConnectEvent([[maybe_unused]] int index);
+    void OnGamepadDisconnectEvent([[maybe_unused]] int index);
+    SoftwareKeyboard::AndroidKeyboard* SoftwareKeyboard();
+
+private:
+    static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max);
+    static void OnEmulationStarted();
+    static void OnEmulationStopped(Core::SystemResultStatus result);
+
+private:
+    // Window management
+    std::unique_ptr<EmuWindow_Android> m_window;
+    ANativeWindow* m_native_window{};
+
+    // Core emulation
+    Core::System m_system;
+    InputCommon::InputSubsystem m_input_subsystem;
+    Common::DetachedTasks m_detached_tasks;
+    Core::PerfStatsResults m_perf_stats{};
+    std::shared_ptr<FileSys::VfsFilesystem> m_vfs;
+    Core::SystemResultStatus m_load_result{Core::SystemResultStatus::ErrorNotInitialized};
+    std::atomic<bool> m_is_running = false;
+    std::atomic<bool> m_is_paused = false;
+    SoftwareKeyboard::AndroidKeyboard* m_software_keyboard{};
+    std::unique_ptr<Service::Account::ProfileManager> m_profile_manager;
+    std::unique_ptr<FileSys::ManualContentProvider> m_manual_provider;
+
+    // GPU driver parameters
+    std::shared_ptr<Common::DynamicLibrary> m_vulkan_library;
+
+    // Synchronization
+    std::condition_variable_any m_cv;
+    mutable std::mutex m_perf_stats_mutex;
+    mutable std::mutex m_mutex;
+};

src/android/app/src/main/res/layout/card_game.xml

@@ -1,63 +1,54 @@
 <?xml version="1.0" encoding="utf-8"?>
-<FrameLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="wrap_content">
 
     <com.google.android.material.card.MaterialCardView
-        style="?attr/materialCardViewElevatedStyle"
         android:id="@+id/card_game"
+        style="?attr/materialCardViewElevatedStyle"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
+        android:layout_gravity="center"
         android:background="?attr/selectableItemBackground"
         android:clickable="true"
         android:clipToPadding="false"
         android:focusable="true"
         android:transitionName="card_game"
-        android:layout_gravity="center"
-        app:cardElevation="0dp"
-        app:cardCornerRadius="12dp">
+        app:cardCornerRadius="4dp"
+        app:cardElevation="0dp">
 
         <androidx.constraintlayout.widget.ConstraintLayout
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:padding="6dp">
 
-            <com.google.android.material.card.MaterialCardView
-                style="?attr/materialCardViewElevatedStyle"
-                android:id="@+id/card_game_art"
+            <com.google.android.material.imageview.ShapeableImageView
+                android:id="@+id/image_game_screen"
                 android:layout_width="150dp"
                 android:layout_height="150dp"
-                app:cardCornerRadius="4dp"
                 app:layout_constraintEnd_toEndOf="parent"
                 app:layout_constraintStart_toStartOf="parent"
-                app:layout_constraintTop_toTopOf="parent">
-
-                <ImageView
-                    android:id="@+id/image_game_screen"
-                    android:layout_width="match_parent"
-                    android:layout_height="match_parent"
-                    tools:src="@drawable/default_icon" />
-
-            </com.google.android.material.card.MaterialCardView>
+                app:layout_constraintTop_toTopOf="parent"
+                app:shapeAppearance="@style/ShapeAppearance.Material3.Corner.ExtraSmall"
+                tools:src="@drawable/default_icon" />
 
             <com.google.android.material.textview.MaterialTextView
-                style="@style/TextAppearance.Material3.TitleMedium"
                 android:id="@+id/text_game_title"
+                style="@style/TextAppearance.Material3.TitleMedium"
                 android:layout_width="0dp"
                 android:layout_height="wrap_content"
                 android:layout_marginTop="8dp"
+                android:ellipsize="none"
+                android:marqueeRepeatLimit="marquee_forever"
+                android:requiresFadingEdge="horizontal"
+                android:singleLine="true"
                 android:textAlignment="center"
                 android:textSize="14sp"
-                android:singleLine="true"
-                android:marqueeRepeatLimit="marquee_forever"
-                android:ellipsize="none"
-                android:requiresFadingEdge="horizontal"
-                app:layout_constraintEnd_toEndOf="@+id/card_game_art"
-                app:layout_constraintStart_toStartOf="@+id/card_game_art"
-                app:layout_constraintTop_toBottomOf="@+id/card_game_art"
+                app:layout_constraintEnd_toEndOf="@+id/image_game_screen"
+                app:layout_constraintStart_toStartOf="@+id/image_game_screen"
+                app:layout_constraintTop_toBottomOf="@+id/image_game_screen"
                 tools:text="The Legend of Zelda: Skyward Sword" />
 
         </androidx.constraintlayout.widget.ConstraintLayout>

src/android/app/src/main/res/layout/card_home_option.xml

@@ -16,7 +16,8 @@
     <LinearLayout
         android:id="@+id/option_layout"
         android:layout_width="match_parent"
-        android:layout_height="wrap_content">
+        android:layout_height="wrap_content"
+        android:layout_gravity="center_vertical">
 
         <ImageView
             android:id="@+id/option_icon"

src/common/CMakeLists.txt

@@ -120,6 +120,8 @@ add_library(common STATIC
     socket_types.h
     spin_lock.cpp
     spin_lock.h
+    stb.cpp
+    stb.h
     steady_clock.cpp
     steady_clock.h
     stream.cpp
@@ -208,6 +210,8 @@ if (MSVC)
     /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
     /we4800 # Implicit conversion from 'type' to bool. Possible information loss
   )
+else()
+  set_source_files_properties(stb.cpp PROPERTIES COMPILE_OPTIONS "-Wno-implicit-fallthrough;-Wno-missing-declarations;-Wno-missing-field-initializers")
 endif()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
@@ -223,7 +227,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile Threads::Threads)
+target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile stb::headers Threads::Threads)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd LLVM::Demangle)
 
 if (ANDROID)

src/common/fs/fs_android.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/fs/fs_android.h"
+#include "common/string_util.h"
 
 namespace Common::FS::Android {
 
@@ -28,28 +29,35 @@ void RegisterCallbacks(JNIEnv* env, jclass clazz) {
     env->GetJavaVM(&g_jvm);
     native_library = clazz;
 
+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature)                                \
+    F(JMethodID, JMethodName, Signature)
 #define FR(FunctionName, ReturnValue, JMethodID, Caller, JMethodName, Signature)                   \
     F(JMethodID, JMethodName, Signature)
 #define FS(FunctionName, ReturnValue, Parameters, JMethodID, JMethodName, Signature)               \
     F(JMethodID, JMethodName, Signature)
 #define F(JMethodID, JMethodName, Signature)                                                       \
     JMethodID = env->GetStaticMethodID(native_library, JMethodName, Signature);
+    ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
     ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
     ANDROID_STORAGE_FUNCTIONS(FS)
 #undef F
 #undef FS
 #undef FR
+#undef FH
 }
 
 void UnRegisterCallbacks() {
+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FR(FunctionName, ReturnValue, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FS(FunctionName, ReturnValue, Parameters, JMethodID, JMethodName, Signature) F(JMethodID)
 #define F(JMethodID) JMethodID = nullptr;
+    ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
     ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
     ANDROID_STORAGE_FUNCTIONS(FS)
 #undef F
 #undef FS
 #undef FR
+#undef FH
 }
 
 bool IsContentUri(const std::string& path) {
@@ -95,4 +103,29 @@ ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
 #undef F
 #undef FR
 
+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature)                                \
+    F(FunctionName, JMethodID, Caller)
+#define F(FunctionName, JMethodID, Caller)                                                         \
+    std::string FunctionName(const std::string& filepath) {                                        \
+        if (JMethodID == nullptr) {                                                                \
+            return 0;                                                                              \
+        }                                                                                          \
+        auto env = GetEnvForThread();                                                              \
+        jstring j_filepath = env->NewStringUTF(filepath.c_str());                                  \
+        jstring j_return =                                                                         \
+            static_cast<jstring>(env->Caller(native_library, JMethodID, j_filepath));              \
+        if (!j_return) {                                                                           \
+            return {};                                                                             \
+        }                                                                                          \
+        const jchar* jchars = env->GetStringChars(j_return, nullptr);                              \
+        const jsize length = env->GetStringLength(j_return);                                       \
+        const std::u16string_view string_view(reinterpret_cast<const char16_t*>(jchars), length);  \
+        const std::string converted_string = Common::UTF16ToUTF8(string_view);                     \
+        env->ReleaseStringChars(j_return, jchars);                                                 \
+        return converted_string;                                                                   \
+    }
+ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
+#undef F
+#undef FH
+
 } // namespace Common::FS::Android

src/common/fs/fs_android.h

@@ -17,19 +17,28 @@
       "(Ljava/lang/String;)Z")                                                                     \
     V(Exists, bool, file_exists, CallStaticBooleanMethod, "exists", "(Ljava/lang/String;)Z")
 
+#define ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(V)                                                    \
+    V(GetParentDirectory, get_parent_directory, CallStaticObjectMethod, "getParentDirectory",      \
+      "(Ljava/lang/String;)Ljava/lang/String;")                                                    \
+    V(GetFilename, get_filename, CallStaticObjectMethod, "getFilename",                            \
+      "(Ljava/lang/String;)Ljava/lang/String;")
+
 namespace Common::FS::Android {
 
 static JavaVM* g_jvm = nullptr;
 static jclass native_library = nullptr;
 
+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FR(FunctionName, ReturnValue, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FS(FunctionName, ReturnValue, Parameters, JMethodID, JMethodName, Signature) F(JMethodID)
 #define F(JMethodID) static jmethodID JMethodID = nullptr;
+ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
 ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
 ANDROID_STORAGE_FUNCTIONS(FS)
 #undef F
 #undef FS
 #undef FR
+#undef FH
 
 enum class OpenMode {
     Read,
@@ -62,4 +71,10 @@ ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
 #undef F
 #undef FR
 
+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature) F(FunctionName)
+#define F(FunctionName) std::string FunctionName(const std::string& filepath);
+ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
+#undef F
+#undef FH
+
 } // namespace Common::FS::Android

src/common/fs/fs_paths.h

@@ -13,6 +13,7 @@
 #define AMIIBO_DIR "amiibo"
 #define CACHE_DIR "cache"
 #define CONFIG_DIR "config"
+#define CRASH_DUMPS_DIR "crash_dumps"
 #define DUMP_DIR "dump"
 #define KEYS_DIR "keys"
 #define LOAD_DIR "load"

src/common/fs/path_util.cpp

@@ -119,6 +119,7 @@ public:
         GenerateYuzuPath(YuzuPath::AmiiboDir, yuzu_path / AMIIBO_DIR);
         GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path_cache);
         GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path_config);
+        GenerateYuzuPath(YuzuPath::CrashDumpsDir, yuzu_path / CRASH_DUMPS_DIR);
         GenerateYuzuPath(YuzuPath::DumpDir, yuzu_path / DUMP_DIR);
         GenerateYuzuPath(YuzuPath::KeysDir, yuzu_path / KEYS_DIR);
         GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);
@@ -400,6 +401,16 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
 }
 
 std::string_view GetParentPath(std::string_view path) {
+    if (path.empty()) {
+        return path;
+    }
+
+#ifdef ANDROID
+    if (path[0] != '/') {
+        std::string path_string{path};
+        return FS::Android::GetParentDirectory(path_string);
+    }
+#endif
     const auto name_bck_index = path.rfind('\\');
     const auto name_fwd_index = path.rfind('/');
     std::size_t name_index;

src/common/fs/path_util.h

@@ -15,6 +15,7 @@ enum class YuzuPath {
     AmiiboDir,      // Where Amiibo backups are stored.
     CacheDir,       // Where cached filesystem data is stored.
     ConfigDir,      // Where config files are stored.
+    CrashDumpsDir,  // Where crash dumps are stored.
     DumpDir,        // Where dumped data is stored.
     KeysDir,        // Where key files are stored.
     LoadDir,        // Where cheat/mod files are stored.

src/common/nvidia_flags.cpp

@@ -25,6 +25,7 @@ void ConfigureNvidiaEnvironmentFlags() {
 
     void(_putenv(fmt::format("__GL_SHADER_DISK_CACHE_PATH={}", windows_path_string).c_str()));
     void(_putenv("__GL_SHADER_DISK_CACHE_SKIP_CLEANUP=1"));
+    void(_putenv("__GL_THREADED_OPTIMIZATIONS=1"));
 #endif
 }
 

src/common/settings.h

@@ -505,7 +505,6 @@ struct Values {
         linkage, false, "use_auto_stub", Category::Debugging, Specialization::Default, false};
     Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers",
                                          Category::Debugging};
-    Setting<bool> create_crash_dumps{linkage, false, "create_crash_dumps", Category::Debugging};
     Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging};
 
     // Miscellaneous

src/common/stb.cpp

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+
+#include "common/stb.h"

src/common/stb.h

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <stb_image.h>
+#include <stb_image_resize.h>
+#include <stb_image_write.h>

src/common/string_util.cpp

@@ -14,6 +14,10 @@
 #include <windows.h>
 #endif
 
+#ifdef ANDROID
+#include <common/fs/fs_android.h>
+#endif
+
 namespace Common {
 
 /// Make a string lowercase
@@ -63,6 +67,14 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     if (full_path.empty())
         return false;
 
+#ifdef ANDROID
+    if (full_path[0] != '/') {
+        *_pPath = Common::FS::Android::GetParentDirectory(full_path);
+        *_pFilename = Common::FS::Android::GetFilename(full_path);
+        return true;
+    }
+#endif
+
     std::size_t dir_end = full_path.find_last_of("/"
 // windows needs the : included for something like just "C:" to be considered a directory
 #ifdef _WIN32

src/common/thread.cpp

@@ -11,6 +11,7 @@
 #include <mach/mach.h>
 #elif defined(_WIN32)
 #include <windows.h>
+#include "common/string_util.h"
 #else
 #if defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 #include <pthread_np.h>
@@ -82,29 +83,8 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
 #ifdef _MSC_VER
 
 // Sets the debugger-visible name of the current thread.
-// Uses trick documented in:
-// https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code
 void SetCurrentThreadName(const char* name) {
-    static const DWORD MS_VC_EXCEPTION = 0x406D1388;
-
-#pragma pack(push, 8)
-    struct THREADNAME_INFO {
-        DWORD dwType;     // must be 0x1000
-        LPCSTR szName;    // pointer to name (in user addr space)
-        DWORD dwThreadID; // thread ID (-1=caller thread)
-        DWORD dwFlags;    // reserved for future use, must be zero
-    } info;
-#pragma pack(pop)
-
-    info.dwType = 0x1000;
-    info.szName = name;
-    info.dwThreadID = std::numeric_limits<DWORD>::max();
-    info.dwFlags = 0;
-
-    __try {
-        RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
-    } __except (EXCEPTION_CONTINUE_EXECUTION) {
-    }
+    SetThreadDescription(GetCurrentThread(), UTF8ToUTF16W(name).data());
 }
 
 #else // !MSVC_VER, so must be POSIX threads

src/core/arm/arm_interface.cpp

@@ -86,9 +86,9 @@ void ARM_Interface::SymbolicateBacktrace(Core::System& system, std::vector<Backt
 
     std::map<std::string, Symbols::Symbols> symbols;
     for (const auto& module : modules) {
-        symbols.insert_or_assign(
-            module.second, Symbols::GetSymbols(module.first, system.ApplicationMemory(),
-                                               system.ApplicationProcess()->Is64BitProcess()));
+        symbols.insert_or_assign(module.second,
+                                 Symbols::GetSymbols(module.first, system.ApplicationMemory(),
+                                                     system.ApplicationProcess()->Is64Bit()));
     }
 
     for (auto& entry : out) {

src/core/core.cpp

@@ -309,17 +309,10 @@ struct System::Impl {
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
 
-        // Create a resource limit for the process.
-        const auto physical_memory_size =
-            kernel.MemoryManager().GetSize(Kernel::KMemoryManager::Pool::Application);
-        auto* resource_limit = Kernel::CreateResourceLimitForProcess(system, physical_memory_size);
-
         // Create the process.
         auto main_process = Kernel::KProcess::Create(system.Kernel());
-        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
-                                            Kernel::KProcess::ProcessType::Userland, resource_limit)
-                   .IsSuccess());
         Kernel::KProcess::Register(system.Kernel(), main_process);
+        kernel.AppendNewProcess(main_process);
         kernel.MakeApplicationProcess(main_process);
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
@@ -418,6 +411,7 @@ struct System::Impl {
             services->KillNVNFlinger();
         }
         kernel.CloseServices();
+        kernel.ShutdownCores();
         services.reset();
         service_manager.reset();
         cheat_engine.reset();
@@ -429,7 +423,6 @@ struct System::Impl {
         gpu_core.reset();
         host1x_core.reset();
         perf_stats.reset();
-        kernel.ShutdownCores();
         cpu_manager.Shutdown();
         debugger.reset();
         kernel.Shutdown();

src/core/debugger/debugger.cpp

@@ -258,20 +258,20 @@ private:
         Kernel::KScopedSchedulerLock sl{system.Kernel()};
 
         // Put all threads to sleep on next scheduler round.
-        for (auto* thread : ThreadList()) {
-            thread->RequestSuspend(Kernel::SuspendType::Debug);
+        for (auto& thread : ThreadList()) {
+            thread.RequestSuspend(Kernel::SuspendType::Debug);
         }
     }
 
     void ResumeEmulation(Kernel::KThread* except = nullptr) {
         // Wake up all threads.
-        for (auto* thread : ThreadList()) {
-            if (thread == except) {
+        for (auto& thread : ThreadList()) {
+            if (std::addressof(thread) == except) {
                 continue;
             }
 
-            thread->SetStepState(Kernel::StepState::NotStepping);
-            thread->Resume(Kernel::SuspendType::Debug);
+            thread.SetStepState(Kernel::StepState::NotStepping);
+            thread.Resume(Kernel::SuspendType::Debug);
         }
     }
 
@@ -283,13 +283,17 @@ private:
     }
 
     void UpdateActiveThread() {
-        const auto& threads{ThreadList()};
-        if (std::find(threads.begin(), threads.end(), state->active_thread) == threads.end()) {
-            state->active_thread = threads.front();
+        auto& threads{ThreadList()};
+        for (auto& thread : threads) {
+            if (std::addressof(thread) == state->active_thread) {
+                // Thread is still alive, no need to update.
+                return;
+            }
         }
+        state->active_thread = std::addressof(threads.front());
     }
 
-    const std::list<Kernel::KThread*>& ThreadList() {
+    Kernel::KProcess::ThreadList& ThreadList() {
         return system.ApplicationProcess()->GetThreadList();
     }
 

src/core/debugger/gdbstub.cpp

@@ -109,7 +109,7 @@ static std::string EscapeXML(std::string_view data) {
 
 GDBStub::GDBStub(DebuggerBackend& backend_, Core::System& system_)
     : DebuggerFrontend(backend_), system{system_} {
-    if (system.ApplicationProcess()->Is64BitProcess()) {
+    if (system.ApplicationProcess()->Is64Bit()) {
         arch = std::make_unique<GDBStubA64>();
     } else {
         arch = std::make_unique<GDBStubA32>();
@@ -446,10 +446,10 @@ void GDBStub::HandleBreakpointRemove(std::string_view command) {
 // See osdbg_thread_local_region.os.horizon.hpp and osdbg_thread_type.os.horizon.hpp
 
 static std::optional<std::string> GetNameFromThreadType32(Core::Memory::Memory& memory,
-                                                          const Kernel::KThread* thread) {
+                                                          const Kernel::KThread& thread) {
     // Read thread type from TLS
-    const VAddr tls_thread_type{memory.Read32(thread->GetTlsAddress() + 0x1fc)};
-    const VAddr argument_thread_type{thread->GetArgument()};
+    const VAddr tls_thread_type{memory.Read32(thread.GetTlsAddress() + 0x1fc)};
+    const VAddr argument_thread_type{thread.GetArgument()};
 
     if (argument_thread_type && tls_thread_type != argument_thread_type) {
         // Probably not created by nnsdk, no name available.
@@ -477,10 +477,10 @@ static std::optional<std::string> GetNameFromThreadType32(Core::Memory::Memory&
 }
 
 static std::optional<std::string> GetNameFromThreadType64(Core::Memory::Memory& memory,
-                                                          const Kernel::KThread* thread) {
+                                                          const Kernel::KThread& thread) {
     // Read thread type from TLS
-    const VAddr tls_thread_type{memory.Read64(thread->GetTlsAddress() + 0x1f8)};
-    const VAddr argument_thread_type{thread->GetArgument()};
+    const VAddr tls_thread_type{memory.Read64(thread.GetTlsAddress() + 0x1f8)};
+    const VAddr argument_thread_type{thread.GetArgument()};
 
     if (argument_thread_type && tls_thread_type != argument_thread_type) {
         // Probably not created by nnsdk, no name available.
@@ -508,16 +508,16 @@ static std::optional<std::string> GetNameFromThreadType64(Core::Memory::Memory&
 }
 
 static std::optional<std::string> GetThreadName(Core::System& system,
-                                                const Kernel::KThread* thread) {
-    if (system.ApplicationProcess()->Is64BitProcess()) {
+                                                const Kernel::KThread& thread) {
+    if (system.ApplicationProcess()->Is64Bit()) {
         return GetNameFromThreadType64(system.ApplicationMemory(), thread);
     } else {
         return GetNameFromThreadType32(system.ApplicationMemory(), thread);
     }
 }
 
-static std::string_view GetThreadWaitReason(const Kernel::KThread* thread) {
-    switch (thread->GetWaitReasonForDebugging()) {
+static std::string_view GetThreadWaitReason(const Kernel::KThread& thread) {
+    switch (thread.GetWaitReasonForDebugging()) {
     case Kernel::ThreadWaitReasonForDebugging::Sleep:
         return "Sleep";
     case Kernel::ThreadWaitReasonForDebugging::IPC:
@@ -535,8 +535,8 @@ static std::string_view GetThreadWaitReason(const Kernel::KThread* thread) {
     }
 }
 
-static std::string GetThreadState(const Kernel::KThread* thread) {
-    switch (thread->GetState()) {
+static std::string GetThreadState(const Kernel::KThread& thread) {
+    switch (thread.GetState()) {
     case Kernel::ThreadState::Initialized:
         return "Initialized";
     case Kernel::ThreadState::Waiting:
@@ -604,7 +604,7 @@ void GDBStub::HandleQuery(std::string_view command) {
         const auto& threads = system.ApplicationProcess()->GetThreadList();
         std::vector<std::string> thread_ids;
         for (const auto& thread : threads) {
-            thread_ids.push_back(fmt::format("{:x}", thread->GetThreadId()));
+            thread_ids.push_back(fmt::format("{:x}", thread.GetThreadId()));
         }
         SendReply(fmt::format("m{}", fmt::join(thread_ids, ",")));
     } else if (command.starts_with("sThreadInfo")) {
@@ -616,14 +616,14 @@ void GDBStub::HandleQuery(std::string_view command) {
         buffer += "<threads>";
 
         const auto& threads = system.ApplicationProcess()->GetThreadList();
-        for (const auto* thread : threads) {
+        for (const auto& thread : threads) {
             auto thread_name{GetThreadName(system, thread)};
             if (!thread_name) {
-                thread_name = fmt::format("Thread {:d}", thread->GetThreadId());
+                thread_name = fmt::format("Thread {:d}", thread.GetThreadId());
             }
 
             buffer += fmt::format(R"(<thread id="{:x}" core="{:d}" name="{}">{}</thread>)",
-                                  thread->GetThreadId(), thread->GetActiveCore(),
+                                  thread.GetThreadId(), thread.GetActiveCore(),
                                   EscapeXML(*thread_name), GetThreadState(thread));
         }
 
@@ -850,10 +850,10 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
 }
 
 Kernel::KThread* GDBStub::GetThreadByID(u64 thread_id) {
-    const auto& threads{system.ApplicationProcess()->GetThreadList()};
-    for (auto* thread : threads) {
-        if (thread->GetThreadId() == thread_id) {
-            return thread;
+    auto& threads{system.ApplicationProcess()->GetThreadList()};
+    for (auto& thread : threads) {
+        if (thread.GetThreadId() == thread_id) {
+            return std::addressof(thread);
         }
     }
 

src/core/file_sys/program_metadata.cpp

@@ -104,16 +104,16 @@ Loader::ResultStatus ProgramMetadata::Reload(VirtualFile file) {
 }
 
 /*static*/ ProgramMetadata ProgramMetadata::GetDefault() {
-    // Allow use of cores 0~3 and thread priorities 1~63.
-    constexpr u32 default_thread_info_capability = 0x30007F7;
+    // Allow use of cores 0~3 and thread priorities 16~63.
+    constexpr u32 default_thread_info_capability = 0x30043F7;
 
     ProgramMetadata result;
 
     result.LoadManual(
         true /*is_64_bit*/, FileSys::ProgramAddressSpaceType::Is39Bit /*address_space*/,
-        0x2c /*main_thread_prio*/, 0 /*main_thread_core*/, 0x00100000 /*main_thread_stack_size*/,
-        0 /*title_id*/, 0xFFFFFFFFFFFFFFFF /*filesystem_permissions*/,
-        0x1FE00000 /*system_resource_size*/, {default_thread_info_capability} /*capabilities*/);
+        0x2c /*main_thread_prio*/, 0 /*main_thread_core*/, 0x100000 /*main_thread_stack_size*/,
+        0 /*title_id*/, 0xFFFFFFFFFFFFFFFF /*filesystem_permissions*/, 0 /*system_resource_size*/,
+        {default_thread_info_capability} /*capabilities*/);
 
     return result;
 }

src/core/file_sys/program_metadata.h

@@ -73,6 +73,9 @@ public:
     u64 GetFilesystemPermissions() const;
     u32 GetSystemResourceSize() const;
     const KernelCapabilityDescriptors& GetKernelCapabilities() const;
+    const std::array<u8, 0x10>& GetName() const {
+        return npdm_header.application_name;
+    }
 
     void Print() const;
 
@@ -164,14 +167,14 @@ private:
         u32_le unk_size_2;
     };
 
-    Header npdm_header;
-    AciHeader aci_header;
-    AcidHeader acid_header;
+    Header npdm_header{};
+    AciHeader aci_header{};
+    AcidHeader acid_header{};
 
-    FileAccessControl acid_file_access;
-    FileAccessHeader aci_file_access;
+    FileAccessControl acid_file_access{};
+    FileAccessHeader aci_file_access{};
 
-    KernelCapabilityDescriptors aci_kernel_capabilities;
+    KernelCapabilityDescriptors aci_kernel_capabilities{};
 };
 
 } // namespace FileSys

src/core/file_sys/system_archive/system_version.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/logging/log.h"
 #include "core/file_sys/system_archive/system_version.h"
 #include "core/file_sys/vfs_vector.h"
 #include "core/hle/api_version.h"
@@ -12,6 +13,9 @@ std::string GetLongDisplayVersion() {
 }
 
 VirtualDir SystemVersion() {
+    LOG_WARNING(Common_Filesystem, "called - Using hardcoded firmware version '{}'",
+                GetLongDisplayVersion());
+
     VirtualFile file = std::make_shared<VectorVfsFile>(std::vector<u8>(0x100), "file");
     file->WriteObject(HLE::ApiVersion::HOS_VERSION_MAJOR, 0);
     file->WriteObject(HLE::ApiVersion::HOS_VERSION_MINOR, 1);

src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp

@@ -8,7 +8,11 @@
 
 #include "core/hle/kernel/board/nintendo/nx/k_system_control.h"
 #include "core/hle/kernel/board/nintendo/nx/secure_monitor.h"
+#include "core/hle/kernel/k_memory_manager.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_trace.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/svc_results.h"
 
 namespace Kernel::Board::Nintendo::Nx {
 
@@ -30,6 +34,8 @@ constexpr const std::size_t RequiredNonSecureSystemMemorySize =
 constexpr const std::size_t RequiredNonSecureSystemMemorySizeWithFatal =
     RequiredNonSecureSystemMemorySize + impl::RequiredNonSecureSystemMemorySizeViFatal;
 
+constexpr const std::size_t SecureAlignment = 128_KiB;
+
 namespace {
 
 using namespace Common::Literals;
@@ -183,4 +189,57 @@ u64 KSystemControl::GenerateRandomRange(u64 min, u64 max) {
     return GenerateUniformRange(min, max, GenerateRandomU64);
 }
 
+size_t KSystemControl::CalculateRequiredSecureMemorySize(size_t size, u32 pool) {
+    if (pool == static_cast<u32>(KMemoryManager::Pool::Applet)) {
+        return 0;
+    } else {
+        // return KSystemControlBase::CalculateRequiredSecureMemorySize(size, pool);
+        return size;
+    }
+}
+
+Result KSystemControl::AllocateSecureMemory(KernelCore& kernel, KVirtualAddress* out, size_t size,
+                                            u32 pool) {
+    // Applet secure memory is handled separately.
+    UNIMPLEMENTED_IF(pool == static_cast<u32>(KMemoryManager::Pool::Applet));
+
+    // Ensure the size is aligned.
+    const size_t alignment =
+        (pool == static_cast<u32>(KMemoryManager::Pool::System) ? PageSize : SecureAlignment);
+    R_UNLESS(Common::IsAligned(size, alignment), ResultInvalidSize);
+
+    // Allocate the memory.
+    const size_t num_pages = size / PageSize;
+    const KPhysicalAddress paddr = kernel.MemoryManager().AllocateAndOpenContinuous(
+        num_pages, alignment / PageSize,
+        KMemoryManager::EncodeOption(static_cast<KMemoryManager::Pool>(pool),
+                                     KMemoryManager::Direction::FromFront));
+    R_UNLESS(paddr != 0, ResultOutOfMemory);
+
+    // Ensure we don't leak references to the memory on error.
+    ON_RESULT_FAILURE {
+        kernel.MemoryManager().Close(paddr, num_pages);
+    };
+
+    // We succeeded.
+    *out = KPageTable::GetHeapVirtualAddress(kernel.MemoryLayout(), paddr);
+    R_SUCCEED();
+}
+
+void KSystemControl::FreeSecureMemory(KernelCore& kernel, KVirtualAddress address, size_t size,
+                                      u32 pool) {
+    // Applet secure memory is handled separately.
+    UNIMPLEMENTED_IF(pool == static_cast<u32>(KMemoryManager::Pool::Applet));
+
+    // Ensure the size is aligned.
+    const size_t alignment =
+        (pool == static_cast<u32>(KMemoryManager::Pool::System) ? PageSize : SecureAlignment);
+    ASSERT(Common::IsAligned(GetInteger(address), alignment));
+    ASSERT(Common::IsAligned(size, alignment));
+
+    // Close the secure region's pages.
+    kernel.MemoryManager().Close(KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), address),
+                                 size / PageSize);
+}
+
 } // namespace Kernel::Board::Nintendo::Nx

src/core/hle/kernel/board/nintendo/nx/k_system_control.h

@@ -4,6 +4,11 @@
 #pragma once
 
 #include "core/hle/kernel/k_typed_address.h"
+#include "core/hle/result.h"
+
+namespace Kernel {
+class KernelCore;
+}
 
 namespace Kernel::Board::Nintendo::Nx {
 
@@ -25,8 +30,16 @@ public:
         static std::size_t GetMinimumNonSecureSystemPoolSize();
     };
 
+    // Randomness.
     static u64 GenerateRandomRange(u64 min, u64 max);
     static u64 GenerateRandomU64();
+
+    // Secure Memory.
+    static size_t CalculateRequiredSecureMemorySize(size_t size, u32 pool);
+    static Result AllocateSecureMemory(KernelCore& kernel, KVirtualAddress* out, size_t size,
+                                       u32 pool);
+    static void FreeSecureMemory(KernelCore& kernel, KVirtualAddress address, size_t size,
+                                 u32 pool);
 };
 
 } // namespace Kernel::Board::Nintendo::Nx

src/core/hle/kernel/k_capabilities.h

@@ -200,8 +200,8 @@ private:
 
         RawCapabilityValue raw;
         BitField<0, 15, CapabilityType> id;
-        BitField<15, 4, u32> major_version;
-        BitField<19, 13, u32> minor_version;
+        BitField<15, 4, u32> minor_version;
+        BitField<19, 13, u32> major_version;
     };
 
     union HandleTable {

src/core/hle/kernel/k_condition_variable.cpp

@@ -107,12 +107,12 @@ KConditionVariable::KConditionVariable(Core::System& system)
 
 KConditionVariable::~KConditionVariable() = default;
 
-Result KConditionVariable::SignalToAddress(KProcessAddress addr) {
-    KThread* owner_thread = GetCurrentThreadPointer(m_kernel);
+Result KConditionVariable::SignalToAddress(KernelCore& kernel, KProcessAddress addr) {
+    KThread* owner_thread = GetCurrentThreadPointer(kernel);
 
     // Signal the address.
     {
-        KScopedSchedulerLock sl(m_kernel);
+        KScopedSchedulerLock sl(kernel);
 
         // Remove waiter thread.
         bool has_waiters{};
@@ -133,7 +133,7 @@ Result KConditionVariable::SignalToAddress(KProcessAddress addr) {
 
         // Write the value to userspace.
         Result result{ResultSuccess};
-        if (WriteToUser(m_kernel, addr, std::addressof(next_value))) [[likely]] {
+        if (WriteToUser(kernel, addr, std::addressof(next_value))) [[likely]] {
             result = ResultSuccess;
         } else {
             result = ResultInvalidCurrentMemory;
@@ -148,28 +148,28 @@ Result KConditionVariable::SignalToAddress(KProcessAddress addr) {
     }
 }
 
-Result KConditionVariable::WaitForAddress(Handle handle, KProcessAddress addr, u32 value) {
-    KThread* cur_thread = GetCurrentThreadPointer(m_kernel);
-    ThreadQueueImplForKConditionVariableWaitForAddress wait_queue(m_kernel);
+Result KConditionVariable::WaitForAddress(KernelCore& kernel, Handle handle, KProcessAddress addr,
+                                          u32 value) {
+    KThread* cur_thread = GetCurrentThreadPointer(kernel);
+    ThreadQueueImplForKConditionVariableWaitForAddress wait_queue(kernel);
 
     // Wait for the address.
     KThread* owner_thread{};
     {
-        KScopedSchedulerLock sl(m_kernel);
+        KScopedSchedulerLock sl(kernel);
 
         // Check if the thread should terminate.
         R_UNLESS(!cur_thread->IsTerminationRequested(), ResultTerminationRequested);
 
         // Read the tag from userspace.
         u32 test_tag{};
-        R_UNLESS(ReadFromUser(m_kernel, std::addressof(test_tag), addr),
-                 ResultInvalidCurrentMemory);
+        R_UNLESS(ReadFromUser(kernel, std::addressof(test_tag), addr), ResultInvalidCurrentMemory);
 
         // If the tag isn't the handle (with wait mask), we're done.
         R_SUCCEED_IF(test_tag != (handle | Svc::HandleWaitMask));
 
         // Get the lock owner thread.
-        owner_thread = GetCurrentProcess(m_kernel)
+        owner_thread = GetCurrentProcess(kernel)
                            .GetHandleTable()
                            .GetObjectWithoutPseudoHandle<KThread>(handle)
                            .ReleasePointerUnsafe();

src/core/hle/kernel/k_condition_variable.h

@@ -24,11 +24,12 @@ public:
     explicit KConditionVariable(Core::System& system);
     ~KConditionVariable();
 
-    // Arbitration
-    Result SignalToAddress(KProcessAddress addr);
-    Result WaitForAddress(Handle handle, KProcessAddress addr, u32 value);
+    // Arbitration.
+    static Result SignalToAddress(KernelCore& kernel, KProcessAddress addr);
+    static Result WaitForAddress(KernelCore& kernel, Handle handle, KProcessAddress addr,
+                                 u32 value);
 
-    // Condition variable
+    // Condition variable.
     void Signal(u64 cv_key, s32 count);
     Result Wait(KProcessAddress addr, u64 key, u32 value, s64 timeout);
 

src/core/hle/kernel/k_interrupt_manager.cpp

@@ -22,7 +22,7 @@ void HandleInterrupt(KernelCore& kernel, s32 core_id) {
             KScopedSchedulerLock sl{kernel};
 
             // Pin the current thread.
-            process->PinCurrentThread(core_id);
+            process->PinCurrentThread();
 
             // Set the interrupt flag for the thread.
             GetCurrentThread(kernel).SetInterruptFlag();

src/core/hle/kernel/k_memory_manager.cpp

@@ -11,6 +11,7 @@
 #include "core/hle/kernel/initial_process.h"
 #include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_page_group.h"
+#include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 
@@ -168,11 +169,37 @@ void KMemoryManager::Initialize(KVirtualAddress management_region, size_t manage
 }
 
 Result KMemoryManager::InitializeOptimizedMemory(u64 process_id, Pool pool) {
-    UNREACHABLE();
+    const u32 pool_index = static_cast<u32>(pool);
+
+    // Lock the pool.
+    KScopedLightLock lk(m_pool_locks[pool_index]);
+
+    // Check that we don't already have an optimized process.
+    R_UNLESS(!m_has_optimized_process[pool_index], ResultBusy);
+
+    // Set the optimized process id.
+    m_optimized_process_ids[pool_index] = process_id;
+    m_has_optimized_process[pool_index] = true;
+
+    // Clear the management area for the optimized process.
+    for (auto* manager = this->GetFirstManager(pool, Direction::FromFront); manager != nullptr;
+         manager = this->GetNextManager(manager, Direction::FromFront)) {
+        manager->InitializeOptimizedMemory(m_system.Kernel());
+    }
+
+    R_SUCCEED();
 }
 
 void KMemoryManager::FinalizeOptimizedMemory(u64 process_id, Pool pool) {
-    UNREACHABLE();
+    const u32 pool_index = static_cast<u32>(pool);
+
+    // Lock the pool.
+    KScopedLightLock lk(m_pool_locks[pool_index]);
+
+    // If the process was optimized, clear it.
+    if (m_has_optimized_process[pool_index] && m_optimized_process_ids[pool_index] == process_id) {
+        m_has_optimized_process[pool_index] = false;
+    }
 }
 
 KPhysicalAddress KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_pages,
@@ -207,7 +234,7 @@ KPhysicalAddress KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, siz
 
     // Maintain the optimized memory bitmap, if we should.
     if (m_has_optimized_process[static_cast<size_t>(pool)]) {
-        UNIMPLEMENTED();
+        chosen_manager->TrackUnoptimizedAllocation(m_system.Kernel(), allocated_block, num_pages);
     }
 
     // Open the first reference to the pages.
@@ -255,7 +282,8 @@ Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages,
 
                 // Maintain the optimized memory bitmap, if we should.
                 if (unoptimized) {
-                    UNIMPLEMENTED();
+                    cur_manager->TrackUnoptimizedAllocation(m_system.Kernel(), allocated_block,
+                                                            pages_per_alloc);
                 }
 
                 num_pages -= pages_per_alloc;
@@ -358,8 +386,8 @@ Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32
                     // Process part or all of the block.
                     const size_t cur_pages =
                         std::min(remaining_pages, manager.GetPageOffsetToEnd(cur_address));
-                    any_new =
-                        manager.ProcessOptimizedAllocation(cur_address, cur_pages, fill_pattern);
+                    any_new = manager.ProcessOptimizedAllocation(m_system.Kernel(), cur_address,
+                                                                 cur_pages, fill_pattern);
 
                     // Advance.
                     cur_address += cur_pages * PageSize;
@@ -382,7 +410,7 @@ Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32
                     // Track some or all of the current pages.
                     const size_t cur_pages =
                         std::min(remaining_pages, manager.GetPageOffsetToEnd(cur_address));
-                    manager.TrackOptimizedAllocation(cur_address, cur_pages);
+                    manager.TrackOptimizedAllocation(m_system.Kernel(), cur_address, cur_pages);
 
                     // Advance.
                     cur_address += cur_pages * PageSize;
@@ -427,17 +455,86 @@ size_t KMemoryManager::Impl::Initialize(KPhysicalAddress address, size_t size,
     return total_management_size;
 }
 
-void KMemoryManager::Impl::TrackUnoptimizedAllocation(KPhysicalAddress block, size_t num_pages) {
-    UNREACHABLE();
+void KMemoryManager::Impl::InitializeOptimizedMemory(KernelCore& kernel) {
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
+    auto* optimize_map = kernel.System().DeviceMemory().GetPointer<u64>(optimize_pa);
+
+    std::memset(optimize_map, 0, CalculateOptimizedProcessOverheadSize(m_heap.GetSize()));
 }
 
-void KMemoryManager::Impl::TrackOptimizedAllocation(KPhysicalAddress block, size_t num_pages) {
-    UNREACHABLE();
+void KMemoryManager::Impl::TrackUnoptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
+                                                      size_t num_pages) {
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
+    auto* optimize_map = kernel.System().DeviceMemory().GetPointer<u64>(optimize_pa);
+
+    // Get the range we're tracking.
+    size_t offset = this->GetPageOffset(block);
+    const size_t last = offset + num_pages - 1;
+
+    // Track.
+    while (offset <= last) {
+        // Mark the page as not being optimized-allocated.
+        optimize_map[offset / Common::BitSize<u64>()] &=
+            ~(u64(1) << (offset % Common::BitSize<u64>()));
+
+        offset++;
+    }
 }
 
-bool KMemoryManager::Impl::ProcessOptimizedAllocation(KPhysicalAddress block, size_t num_pages,
-                                                      u8 fill_pattern) {
-    UNREACHABLE();
+void KMemoryManager::Impl::TrackOptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
+                                                    size_t num_pages) {
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
+    auto* optimize_map = kernel.System().DeviceMemory().GetPointer<u64>(optimize_pa);
+
+    // Get the range we're tracking.
+    size_t offset = this->GetPageOffset(block);
+    const size_t last = offset + num_pages - 1;
+
+    // Track.
+    while (offset <= last) {
+        // Mark the page as being optimized-allocated.
+        optimize_map[offset / Common::BitSize<u64>()] |=
+            (u64(1) << (offset % Common::BitSize<u64>()));
+
+        offset++;
+    }
+}
+
+bool KMemoryManager::Impl::ProcessOptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
+                                                      size_t num_pages, u8 fill_pattern) {
+    auto& device_memory = kernel.System().DeviceMemory();
+    auto optimize_pa =
+        KPageTable::GetHeapPhysicalAddress(kernel.MemoryLayout(), m_management_region);
+    auto* optimize_map = device_memory.GetPointer<u64>(optimize_pa);
+
+    // We want to return whether any pages were newly allocated.
+    bool any_new = false;
+
+    // Get the range we're processing.
+    size_t offset = this->GetPageOffset(block);
+    const size_t last = offset + num_pages - 1;
+
+    // Process.
+    while (offset <= last) {
+        // Check if the page has been optimized-allocated before.
+        if ((optimize_map[offset / Common::BitSize<u64>()] &
+             (u64(1) << (offset % Common::BitSize<u64>()))) == 0) {
+            // If not, it's new.
+            any_new = true;
+
+            // Fill the page.
+            auto* ptr = device_memory.GetPointer<u8>(m_heap.GetAddress());
+            std::memset(ptr + offset * PageSize, fill_pattern, PageSize);
+        }
+
+        offset++;
+    }
+
+    // Return the number of pages we processed.
+    return any_new;
 }
 
 size_t KMemoryManager::Impl::CalculateManagementOverheadSize(size_t region_size) {

src/core/hle/kernel/k_memory_manager.h

@@ -216,14 +216,14 @@ private:
             m_heap.SetInitialUsedSize(reserved_size);
         }
 
-        void InitializeOptimizedMemory() {
-            UNIMPLEMENTED();
-        }
+        void InitializeOptimizedMemory(KernelCore& kernel);
 
-        void TrackUnoptimizedAllocation(KPhysicalAddress block, size_t num_pages);
-        void TrackOptimizedAllocation(KPhysicalAddress block, size_t num_pages);
+        void TrackUnoptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
+                                        size_t num_pages);
+        void TrackOptimizedAllocation(KernelCore& kernel, KPhysicalAddress block, size_t num_pages);
 
-        bool ProcessOptimizedAllocation(KPhysicalAddress block, size_t num_pages, u8 fill_pattern);
+        bool ProcessOptimizedAllocation(KernelCore& kernel, KPhysicalAddress block,
+                                        size_t num_pages, u8 fill_pattern);
 
         constexpr Pool GetPool() const {
             return m_pool;

src/core/hle/kernel/k_page_table.cpp

@@ -82,14 +82,14 @@ public:
 
 using namespace Common::Literals;
 
-constexpr size_t GetAddressSpaceWidthFromType(FileSys::ProgramAddressSpaceType as_type) {
+constexpr size_t GetAddressSpaceWidthFromType(Svc::CreateProcessFlag as_type) {
     switch (as_type) {
-    case FileSys::ProgramAddressSpaceType::Is32Bit:
-    case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
+    case Svc::CreateProcessFlag::AddressSpace32Bit:
+    case Svc::CreateProcessFlag::AddressSpace32BitWithoutAlias:
         return 32;
-    case FileSys::ProgramAddressSpaceType::Is36Bit:
+    case Svc::CreateProcessFlag::AddressSpace64BitDeprecated:
         return 36;
-    case FileSys::ProgramAddressSpaceType::Is39Bit:
+    case Svc::CreateProcessFlag::AddressSpace64Bit:
         return 39;
     default:
         ASSERT(false);
@@ -105,7 +105,7 @@ KPageTable::KPageTable(Core::System& system_)
 
 KPageTable::~KPageTable() = default;
 
-Result KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
+Result KPageTable::InitializeForProcess(Svc::CreateProcessFlag as_type, bool enable_aslr,
                                         bool enable_das_merge, bool from_back,
                                         KMemoryManager::Pool pool, KProcessAddress code_addr,
                                         size_t code_size, KSystemResource* system_resource,
@@ -133,7 +133,7 @@ Result KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type
     ASSERT(code_addr + code_size - 1 <= end - 1);
 
     // Adjust heap/alias size if we don't have an alias region
-    if (as_type == FileSys::ProgramAddressSpaceType::Is32BitNoMap) {
+    if (as_type == Svc::CreateProcessFlag::AddressSpace32BitWithoutAlias) {
         heap_region_size += alias_region_size;
         alias_region_size = 0;
     }

src/core/hle/kernel/k_page_table.h

@@ -63,7 +63,7 @@ public:
     explicit KPageTable(Core::System& system_);
     ~KPageTable();
 
-    Result InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
+    Result InitializeForProcess(Svc::CreateProcessFlag as_type, bool enable_aslr,
                                 bool enable_das_merge, bool from_back, KMemoryManager::Pool pool,
                                 KProcessAddress code_addr, size_t code_size,
                                 KSystemResource* system_resource, KResourceLimit* resource_limit,
@@ -400,7 +400,7 @@ public:
     constexpr size_t GetAliasCodeRegionSize() const {
         return m_alias_code_region_end - m_alias_code_region_start;
     }
-    size_t GetNormalMemorySize() {
+    size_t GetNormalMemorySize() const {
         KScopedLightLock lk(m_general_lock);
         return GetHeapSize() + m_mapped_physical_memory_size;
     }

src/core/hle/kernel/k_process.h

@@ -1,59 +1,23 @@
-// SPDX-FileCopyrightText: 2015 Citra Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
-#include <array>
-#include <cstddef>
-#include <list>
 #include <map>
-#include <string>
+
+#include "core/hle/kernel/code_set.h"
 #include "core/hle/kernel/k_address_arbiter.h"
-#include "core/hle/kernel/k_auto_object.h"
+#include "core/hle/kernel/k_capabilities.h"
 #include "core/hle/kernel/k_condition_variable.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_page_table.h"
-#include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/kernel/k_page_table_manager.h"
+#include "core/hle/kernel/k_system_resource.h"
+#include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_thread_local_page.h"
-#include "core/hle/kernel/k_typed_address.h"
-#include "core/hle/kernel/k_worker_task.h"
-#include "core/hle/kernel/process_capability.h"
-#include "core/hle/kernel/slab_helpers.h"
-#include "core/hle/result.h"
-
-namespace Core {
-namespace Memory {
-class Memory;
-};
-
-class System;
-} // namespace Core
-
-namespace FileSys {
-class ProgramMetadata;
-}
 
 namespace Kernel {
 
-class KernelCore;
-class KResourceLimit;
-class KThread;
-class KSharedMemoryInfo;
-class TLSPage;
-
-struct CodeSet;
-
-enum class MemoryRegion : u16 {
-    APPLICATION = 1,
-    SYSTEM = 2,
-    BASE = 3,
-};
-
-enum class ProcessActivity : u32 {
-    Runnable,
-    Paused,
-};
-
 enum class DebugWatchpointType : u8 {
     None = 0,
     Read = 1 << 0,
@@ -72,9 +36,6 @@ class KProcess final : public KAutoObjectWithSlabHeapAndContainer<KProcess, KWor
     KERNEL_AUTOOBJECT_TRAITS(KProcess, KSynchronizationObject);
 
 public:
-    explicit KProcess(KernelCore& kernel);
-    ~KProcess() override;
-
     enum class State {
         Created = static_cast<u32>(Svc::ProcessState::Created),
         CreatedAttached = static_cast<u32>(Svc::ProcessState::CreatedAttached),
@@ -86,337 +47,83 @@ public:
         DebugBreak = static_cast<u32>(Svc::ProcessState::DebugBreak),
     };
 
-    enum : u64 {
-        /// Lowest allowed process ID for a kernel initial process.
-        InitialKIPIDMin = 1,
-        /// Highest allowed process ID for a kernel initial process.
-        InitialKIPIDMax = 80,
+    using ThreadList = Common::IntrusiveListMemberTraits<&KThread::m_process_list_node>::ListType;
 
-        /// Lowest allowed process ID for a userland process.
-        ProcessIDMin = 81,
-        /// Highest allowed process ID for a userland process.
-        ProcessIDMax = 0xFFFFFFFFFFFFFFFF,
-    };
+    static constexpr size_t AslrAlignment = 2_MiB;
 
-    // Used to determine how process IDs are assigned.
-    enum class ProcessType {
-        KernelInternal,
-        Userland,
-    };
+public:
+    static constexpr u64 InitialProcessIdMin = 1;
+    static constexpr u64 InitialProcessIdMax = 0x50;
 
-    static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
-
-    static Result Initialize(KProcess* process, Core::System& system, std::string process_name,
-                             ProcessType type, KResourceLimit* res_limit);
-
-    /// Gets a reference to the process' page table.
-    KPageTable& GetPageTable() {
-        return m_page_table;
-    }
-
-    /// Gets const a reference to the process' page table.
-    const KPageTable& GetPageTable() const {
-        return m_page_table;
-    }
-
-    /// Gets a reference to the process' handle table.
-    KHandleTable& GetHandleTable() {
-        return m_handle_table;
-    }
-
-    /// Gets a const reference to the process' handle table.
-    const KHandleTable& GetHandleTable() const {
-        return m_handle_table;
-    }
-
-    /// Gets a reference to process's memory.
-    Core::Memory::Memory& GetMemory() const;
-
-    Result SignalToAddress(KProcessAddress address) {
-        return m_condition_var.SignalToAddress(address);
-    }
-
-    Result WaitForAddress(Handle handle, KProcessAddress address, u32 tag) {
-        return m_condition_var.WaitForAddress(handle, address, tag);
-    }
-
-    void SignalConditionVariable(u64 cv_key, int32_t count) {
-        return m_condition_var.Signal(cv_key, count);
-    }
-
-    Result WaitConditionVariable(KProcessAddress address, u64 cv_key, u32 tag, s64 ns) {
-        R_RETURN(m_condition_var.Wait(address, cv_key, tag, ns));
-    }
-
-    Result SignalAddressArbiter(uint64_t address, Svc::SignalType signal_type, s32 value,
-                                s32 count) {
-        R_RETURN(m_address_arbiter.SignalToAddress(address, signal_type, value, count));
-    }
-
-    Result WaitAddressArbiter(uint64_t address, Svc::ArbitrationType arb_type, s32 value,
-                              s64 timeout) {
-        R_RETURN(m_address_arbiter.WaitForAddress(address, arb_type, value, timeout));
-    }
-
-    KProcessAddress GetProcessLocalRegionAddress() const {
-        return m_plr_address;
-    }
-
-    /// Gets the current status of the process
-    State GetState() const {
-        return m_state;
-    }
-
-    /// Gets the unique ID that identifies this particular process.
-    u64 GetProcessId() const {
-        return m_process_id;
-    }
-
-    /// Gets the program ID corresponding to this process.
-    u64 GetProgramId() const {
-        return m_program_id;
-    }
-
-    KProcessAddress GetEntryPoint() const {
-        return m_code_address;
-    }
-
-    /// Gets the resource limit descriptor for this process
-    KResourceLimit* GetResourceLimit() const;
-
-    /// Gets the ideal CPU core ID for this process
-    u8 GetIdealCoreId() const {
-        return m_ideal_core;
-    }
-
-    /// Checks if the specified thread priority is valid.
-    bool CheckThreadPriority(s32 prio) const {
-        return ((1ULL << prio) & GetPriorityMask()) != 0;
-    }
-
-    /// Gets the bitmask of allowed cores that this process' threads can run on.
-    u64 GetCoreMask() const {
-        return m_capabilities.GetCoreMask();
-    }
-
-    /// Gets the bitmask of allowed thread priorities.
-    u64 GetPriorityMask() const {
-        return m_capabilities.GetPriorityMask();
-    }
-
-    /// Gets the amount of secure memory to allocate for memory management.
-    u32 GetSystemResourceSize() const {
-        return m_system_resource_size;
-    }
-
-    /// Gets the amount of secure memory currently in use for memory management.
-    u32 GetSystemResourceUsage() const {
-        // On hardware, this returns the amount of system resource memory that has
-        // been used by the kernel. This is problematic for Yuzu to emulate, because
-        // system resource memory is used for page tables -- and yuzu doesn't really
-        // have a way to calculate how much memory is required for page tables for
-        // the current process at any given time.
-        // TODO: Is this even worth implementing? Games may retrieve this value via
-        // an SDK function that gets used + available system resource size for debug
-        // or diagnostic purposes. However, it seems unlikely that a game would make
-        // decisions based on how much system memory is dedicated to its page tables.
-        // Is returning a value other than zero wise?
-        return 0;
-    }
-
-    /// Whether this process is an AArch64 or AArch32 process.
-    bool Is64BitProcess() const {
-        return m_is_64bit_process;
-    }
-
-    bool IsSuspended() const {
-        return m_is_suspended;
-    }
-
-    void SetSuspended(bool suspended) {
-        m_is_suspended = suspended;
-    }
-
-    /// Gets the total running time of the process instance in ticks.
-    u64 GetCPUTimeTicks() const {
-        return m_total_process_running_time_ticks;
-    }
-
-    /// Updates the total running time, adding the given ticks to it.
-    void UpdateCPUTimeTicks(u64 ticks) {
-        m_total_process_running_time_ticks += ticks;
-    }
-
-    /// Gets the process schedule count, used for thread yielding
-    s64 GetScheduledCount() const {
-        return m_schedule_count;
-    }
-
-    /// Increments the process schedule count, used for thread yielding.
-    void IncrementScheduledCount() {
-        ++m_schedule_count;
-    }
-
-    void IncrementRunningThreadCount();
-    void DecrementRunningThreadCount();
-
-    void SetRunningThread(s32 core, KThread* thread, u64 idle_count) {
-        m_running_threads[core] = thread;
-        m_running_thread_idle_counts[core] = idle_count;
-    }
-
-    void ClearRunningThread(KThread* thread) {
-        for (size_t i = 0; i < m_running_threads.size(); ++i) {
-            if (m_running_threads[i] == thread) {
-                m_running_threads[i] = nullptr;
-            }
-        }
-    }
-
-    [[nodiscard]] KThread* GetRunningThread(s32 core) const {
-        return m_running_threads[core];
-    }
-
-    bool ReleaseUserException(KThread* thread);
-
-    [[nodiscard]] KThread* GetPinnedThread(s32 core_id) const {
-        ASSERT(0 <= core_id && core_id < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
-        return m_pinned_threads[core_id];
-    }
-
-    /// Gets 8 bytes of random data for svcGetInfo RandomEntropy
-    u64 GetRandomEntropy(std::size_t index) const {
-        return m_random_entropy.at(index);
-    }
-
-    /// Retrieves the total physical memory available to this process in bytes.
-    u64 GetTotalPhysicalMemoryAvailable();
-
-    /// Retrieves the total physical memory available to this process in bytes,
-    /// without the size of the personal system resource heap added to it.
-    u64 GetTotalPhysicalMemoryAvailableWithoutSystemResource();
-
-    /// Retrieves the total physical memory used by this process in bytes.
-    u64 GetTotalPhysicalMemoryUsed();
-
-    /// Retrieves the total physical memory used by this process in bytes,
-    /// without the size of the personal system resource heap added to it.
-    u64 GetTotalPhysicalMemoryUsedWithoutSystemResource();
-
-    /// Gets the list of all threads created with this process as their owner.
-    std::list<KThread*>& GetThreadList() {
-        return m_thread_list;
-    }
-
-    /// Registers a thread as being created under this process,
-    /// adding it to this process' thread list.
-    void RegisterThread(KThread* thread);
-
-    /// Unregisters a thread from this process, removing it
-    /// 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
-    ///      terminated process, then ResultInvalidState will be returned.
-    ///
-    /// @pre The process must be in a signaled state. If this is called on a
-    ///      process instance that is not signaled, ResultInvalidState will be
-    ///      returned.
-    Result Reset();
-
-    /**
-     * Loads process-specifics configuration info with metadata provided
-     * by an executable.
-     *
-     * @param metadata The provided metadata to load process specific info from.
-     *
-     * @returns ResultSuccess if all relevant metadata was able to be
-     *          loaded and parsed. Otherwise, an error code is returned.
-     */
-    Result LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
-                            bool is_hbl);
-
-    /**
-     * Starts the main application thread for this process.
-     *
-     * @param main_thread_priority The priority for the main thread.
-     * @param stack_size           The stack size for the main thread in bytes.
-     */
-    void Run(s32 main_thread_priority, u64 stack_size);
-
-    /**
-     * Prepares a process for termination by stopping all of its threads
-     * and clearing any other resources.
-     */
-    void PrepareForTermination();
-
-    void LoadModule(CodeSet code_set, KProcessAddress base_addr);
-
-    bool IsInitialized() const override {
-        return m_is_initialized;
-    }
-
-    static void PostDestroy(uintptr_t arg) {}
-
-    void Finalize() override;
-
-    u64 GetId() const override {
-        return GetProcessId();
-    }
-
-    bool IsHbl() const {
-        return m_is_hbl;
-    }
-
-    bool IsSignaled() const override;
-
-    void DoWorkerTaskImpl();
-
-    Result SetActivity(ProcessActivity activity);
-
-    void PinCurrentThread(s32 core_id);
-    void UnpinCurrentThread(s32 core_id);
-    void UnpinThread(KThread* thread);
-
-    KLightLock& GetStateLock() {
-        return m_state_lock;
-    }
-
-    Result AddSharedMemory(KSharedMemory* shmem, KProcessAddress address, size_t size);
-    void RemoveSharedMemory(KSharedMemory* shmem, KProcessAddress address, size_t size);
-
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    // Thread-local storage management
-
-    // Marks the next available region as used and returns the address of the slot.
-    [[nodiscard]] Result CreateThreadLocalRegion(KProcessAddress* out);
-
-    // Frees a used TLS slot identified by the given address
-    Result DeleteThreadLocalRegion(KProcessAddress addr);
-
-    ///////////////////////////////////////////////////////////////////////////////////////////////
-    // Debug watchpoint management
-
-    // Attempts to insert a watchpoint into a free slot. Returns false if none are available.
-    bool InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type);
-
-    // Attempts to remove the watchpoint specified by the given parameters.
-    bool RemoveWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type);
-
-    const std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS>& GetWatchpoints() const {
-        return m_watchpoints;
-    }
-
-    const std::string& GetName() {
-        return name;
-    }
+    static constexpr u64 ProcessIdMin = InitialProcessIdMax + 1;
+    static constexpr u64 ProcessIdMax = std::numeric_limits<u64>::max();
 
 private:
+    using SharedMemoryInfoList = Common::IntrusiveListBaseTraits<KSharedMemoryInfo>::ListType;
+    using TLPTree =
+        Common::IntrusiveRedBlackTreeBaseTraits<KThreadLocalPage>::TreeType<KThreadLocalPage>;
+    using TLPIterator = TLPTree::iterator;
+
+private:
+    KPageTable m_page_table;
+    std::atomic<size_t> m_used_kernel_memory_size{};
+    TLPTree m_fully_used_tlp_tree{};
+    TLPTree m_partially_used_tlp_tree{};
+    s32 m_ideal_core_id{};
+    KResourceLimit* m_resource_limit{};
+    KSystemResource* m_system_resource{};
+    size_t m_memory_release_hint{};
+    State m_state{};
+    KLightLock m_state_lock;
+    KLightLock m_list_lock;
+    KConditionVariable m_cond_var;
+    KAddressArbiter m_address_arbiter;
+    std::array<u64, 4> m_entropy{};
+    bool m_is_signaled{};
+    bool m_is_initialized{};
+    bool m_is_application{};
+    bool m_is_default_application_system_resource{};
+    bool m_is_hbl{};
+    std::array<char, 13> m_name{};
+    std::atomic<u16> m_num_running_threads{};
+    Svc::CreateProcessFlag m_flags{};
+    KMemoryManager::Pool m_memory_pool{};
+    s64 m_schedule_count{};
+    KCapabilities m_capabilities{};
+    u64 m_program_id{};
+    u64 m_process_id{};
+    KProcessAddress m_code_address{};
+    size_t m_code_size{};
+    size_t m_main_thread_stack_size{};
+    size_t m_max_process_memory{};
+    u32 m_version{};
+    KHandleTable m_handle_table;
+    KProcessAddress m_plr_address{};
+    KThread* m_exception_thread{};
+    ThreadList m_thread_list{};
+    SharedMemoryInfoList m_shared_memory_list{};
+    bool m_is_suspended{};
+    bool m_is_immortal{};
+    bool m_is_handle_table_initialized{};
+    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{};
+    std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{};
+    std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_switch_counts{};
+    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_pinned_threads{};
+    std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{};
+    std::map<KProcessAddress, u64> m_debug_page_refcounts{};
+    std::atomic<s64> m_cpu_time{};
+    std::atomic<s64> m_num_process_switches{};
+    std::atomic<s64> m_num_thread_switches{};
+    std::atomic<s64> m_num_fpu_switches{};
+    std::atomic<s64> m_num_supervisor_calls{};
+    std::atomic<s64> m_num_ipc_messages{};
+    std::atomic<s64> m_num_ipc_replies{};
+    std::atomic<s64> m_num_ipc_receives{};
+
+private:
+    Result StartTermination();
+    void FinishTermination();
+
     void PinThread(s32 core_id, KThread* thread) {
         ASSERT(0 <= core_id && core_id < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
         ASSERT(thread != nullptr);
@@ -431,6 +138,395 @@ private:
         m_pinned_threads[core_id] = nullptr;
     }
 
+public:
+    explicit KProcess(KernelCore& kernel);
+    ~KProcess() override;
+
+    Result Initialize(const Svc::CreateProcessParameter& params, KResourceLimit* res_limit,
+                      bool is_real);
+
+    Result Initialize(const Svc::CreateProcessParameter& params, const KPageGroup& pg,
+                      std::span<const u32> caps, KResourceLimit* res_limit,
+                      KMemoryManager::Pool pool, bool immortal);
+    Result Initialize(const Svc::CreateProcessParameter& params, std::span<const u32> user_caps,
+                      KResourceLimit* res_limit, KMemoryManager::Pool pool);
+    void Exit();
+
+    const char* GetName() const {
+        return m_name.data();
+    }
+
+    u64 GetProgramId() const {
+        return m_program_id;
+    }
+
+    u64 GetProcessId() const {
+        return m_process_id;
+    }
+
+    State GetState() const {
+        return m_state;
+    }
+
+    u64 GetCoreMask() const {
+        return m_capabilities.GetCoreMask();
+    }
+    u64 GetPhysicalCoreMask() const {
+        return m_capabilities.GetPhysicalCoreMask();
+    }
+    u64 GetPriorityMask() const {
+        return m_capabilities.GetPriorityMask();
+    }
+
+    s32 GetIdealCoreId() const {
+        return m_ideal_core_id;
+    }
+    void SetIdealCoreId(s32 core_id) {
+        m_ideal_core_id = core_id;
+    }
+
+    bool CheckThreadPriority(s32 prio) const {
+        return ((1ULL << prio) & this->GetPriorityMask()) != 0;
+    }
+
+    u32 GetCreateProcessFlags() const {
+        return static_cast<u32>(m_flags);
+    }
+
+    bool Is64Bit() const {
+        return True(m_flags & Svc::CreateProcessFlag::Is64Bit);
+    }
+
+    KProcessAddress GetEntryPoint() const {
+        return m_code_address;
+    }
+
+    size_t GetMainStackSize() const {
+        return m_main_thread_stack_size;
+    }
+
+    KMemoryManager::Pool GetMemoryPool() const {
+        return m_memory_pool;
+    }
+
+    u64 GetRandomEntropy(size_t i) const {
+        return m_entropy[i];
+    }
+
+    bool IsApplication() const {
+        return m_is_application;
+    }
+
+    bool IsDefaultApplicationSystemResource() const {
+        return m_is_default_application_system_resource;
+    }
+
+    bool IsSuspended() const {
+        return m_is_suspended;
+    }
+    void SetSuspended(bool suspended) {
+        m_is_suspended = suspended;
+    }
+
+    Result Terminate();
+
+    bool IsTerminated() const {
+        return m_state == State::Terminated;
+    }
+
+    bool IsPermittedSvc(u32 svc_id) const {
+        return m_capabilities.IsPermittedSvc(svc_id);
+    }
+
+    bool IsPermittedInterrupt(s32 interrupt_id) const {
+        return m_capabilities.IsPermittedInterrupt(interrupt_id);
+    }
+
+    bool IsPermittedDebug() const {
+        return m_capabilities.IsPermittedDebug();
+    }
+
+    bool CanForceDebug() const {
+        return m_capabilities.CanForceDebug();
+    }
+
+    bool IsHbl() const {
+        return m_is_hbl;
+    }
+
+    Kernel::KMemoryManager::Direction GetAllocateOption() const {
+        // TODO: property of the KPageTableBase
+        return KMemoryManager::Direction::FromFront;
+    }
+
+    ThreadList& GetThreadList() {
+        return m_thread_list;
+    }
+    const ThreadList& GetThreadList() const {
+        return m_thread_list;
+    }
+
+    bool EnterUserException();
+    bool LeaveUserException();
+    bool ReleaseUserException(KThread* thread);
+
+    KThread* GetPinnedThread(s32 core_id) const {
+        ASSERT(0 <= core_id && core_id < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
+        return m_pinned_threads[core_id];
+    }
+
+    const Svc::SvcAccessFlagSet& GetSvcPermissions() const {
+        return m_capabilities.GetSvcPermissions();
+    }
+
+    KResourceLimit* GetResourceLimit() const {
+        return m_resource_limit;
+    }
+
+    bool ReserveResource(Svc::LimitableResource which, s64 value);
+    bool ReserveResource(Svc::LimitableResource which, s64 value, s64 timeout);
+    void ReleaseResource(Svc::LimitableResource which, s64 value);
+    void ReleaseResource(Svc::LimitableResource which, s64 value, s64 hint);
+
+    KLightLock& GetStateLock() {
+        return m_state_lock;
+    }
+    KLightLock& GetListLock() {
+        return m_list_lock;
+    }
+
+    KPageTable& GetPageTable() {
+        return m_page_table;
+    }
+    const KPageTable& GetPageTable() const {
+        return m_page_table;
+    }
+
+    KHandleTable& GetHandleTable() {
+        return m_handle_table;
+    }
+    const KHandleTable& GetHandleTable() const {
+        return m_handle_table;
+    }
+
+    size_t GetUsedUserPhysicalMemorySize() const;
+    size_t GetTotalUserPhysicalMemorySize() const;
+    size_t GetUsedNonSystemUserPhysicalMemorySize() const;
+    size_t GetTotalNonSystemUserPhysicalMemorySize() const;
+
+    Result AddSharedMemory(KSharedMemory* shmem, KProcessAddress address, size_t size);
+    void RemoveSharedMemory(KSharedMemory* shmem, KProcessAddress address, size_t size);
+
+    Result CreateThreadLocalRegion(KProcessAddress* out);
+    Result DeleteThreadLocalRegion(KProcessAddress addr);
+
+    KProcessAddress GetProcessLocalRegionAddress() const {
+        return m_plr_address;
+    }
+
+    KThread* GetExceptionThread() const {
+        return m_exception_thread;
+    }
+
+    void AddCpuTime(s64 diff) {
+        m_cpu_time += diff;
+    }
+    s64 GetCpuTime() {
+        return m_cpu_time.load();
+    }
+
+    s64 GetScheduledCount() const {
+        return m_schedule_count;
+    }
+    void IncrementScheduledCount() {
+        ++m_schedule_count;
+    }
+
+    void IncrementRunningThreadCount();
+    void DecrementRunningThreadCount();
+
+    size_t GetRequiredSecureMemorySizeNonDefault() const {
+        if (!this->IsDefaultApplicationSystemResource() && m_system_resource->IsSecureResource()) {
+            auto* secure_system_resource = static_cast<KSecureSystemResource*>(m_system_resource);
+            return secure_system_resource->CalculateRequiredSecureMemorySize();
+        }
+
+        return 0;
+    }
+
+    size_t GetRequiredSecureMemorySize() const {
+        if (m_system_resource->IsSecureResource()) {
+            auto* secure_system_resource = static_cast<KSecureSystemResource*>(m_system_resource);
+            return secure_system_resource->CalculateRequiredSecureMemorySize();
+        }
+
+        return 0;
+    }
+
+    size_t GetTotalSystemResourceSize() const {
+        if (!this->IsDefaultApplicationSystemResource() && m_system_resource->IsSecureResource()) {
+            auto* secure_system_resource = static_cast<KSecureSystemResource*>(m_system_resource);
+            return secure_system_resource->GetSize();
+        }
+
+        return 0;
+    }
+
+    size_t GetUsedSystemResourceSize() const {
+        if (!this->IsDefaultApplicationSystemResource() && m_system_resource->IsSecureResource()) {
+            auto* secure_system_resource = static_cast<KSecureSystemResource*>(m_system_resource);
+            return secure_system_resource->GetUsedSize();
+        }
+
+        return 0;
+    }
+
+    void SetRunningThread(s32 core, KThread* thread, u64 idle_count, u64 switch_count) {
+        m_running_threads[core] = thread;
+        m_running_thread_idle_counts[core] = idle_count;
+        m_running_thread_switch_counts[core] = switch_count;
+    }
+
+    void ClearRunningThread(KThread* thread) {
+        for (size_t i = 0; i < m_running_threads.size(); ++i) {
+            if (m_running_threads[i] == thread) {
+                m_running_threads[i] = nullptr;
+            }
+        }
+    }
+
+    const KSystemResource& GetSystemResource() const {
+        return *m_system_resource;
+    }
+
+    const KMemoryBlockSlabManager& GetMemoryBlockSlabManager() const {
+        return m_system_resource->GetMemoryBlockSlabManager();
+    }
+    const KBlockInfoManager& GetBlockInfoManager() const {
+        return m_system_resource->GetBlockInfoManager();
+    }
+    const KPageTableManager& GetPageTableManager() const {
+        return m_system_resource->GetPageTableManager();
+    }
+
+    KThread* GetRunningThread(s32 core) const {
+        return m_running_threads[core];
+    }
+    u64 GetRunningThreadIdleCount(s32 core) const {
+        return m_running_thread_idle_counts[core];
+    }
+    u64 GetRunningThreadSwitchCount(s32 core) const {
+        return m_running_thread_switch_counts[core];
+    }
+
+    void RegisterThread(KThread* thread);
+    void UnregisterThread(KThread* thread);
+
+    Result Run(s32 priority, size_t stack_size);
+
+    Result Reset();
+
+    void SetDebugBreak() {
+        if (m_state == State::RunningAttached) {
+            this->ChangeState(State::DebugBreak);
+        }
+    }
+
+    void SetAttached() {
+        if (m_state == State::DebugBreak) {
+            this->ChangeState(State::RunningAttached);
+        }
+    }
+
+    Result SetActivity(Svc::ProcessActivity activity);
+
+    void PinCurrentThread();
+    void UnpinCurrentThread();
+    void UnpinThread(KThread* thread);
+
+    void SignalConditionVariable(uintptr_t cv_key, int32_t count) {
+        return m_cond_var.Signal(cv_key, count);
+    }
+
+    Result WaitConditionVariable(KProcessAddress address, uintptr_t cv_key, u32 tag, s64 ns) {
+        R_RETURN(m_cond_var.Wait(address, cv_key, tag, ns));
+    }
+
+    Result SignalAddressArbiter(uintptr_t address, Svc::SignalType signal_type, s32 value,
+                                s32 count) {
+        R_RETURN(m_address_arbiter.SignalToAddress(address, signal_type, value, count));
+    }
+
+    Result WaitAddressArbiter(uintptr_t address, Svc::ArbitrationType arb_type, s32 value,
+                              s64 timeout) {
+        R_RETURN(m_address_arbiter.WaitForAddress(address, arb_type, value, timeout));
+    }
+
+    Result GetThreadList(s32* out_num_threads, KProcessAddress out_thread_ids, s32 max_out_count);
+
+    static void Switch(KProcess* cur_process, KProcess* next_process);
+
+public:
+    // Attempts to insert a watchpoint into a free slot. Returns false if none are available.
+    bool InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type);
+
+    // Attempts to remove the watchpoint specified by the given parameters.
+    bool RemoveWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type);
+
+    const std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS>& GetWatchpoints() const {
+        return m_watchpoints;
+    }
+
+public:
+    Result LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
+                            bool is_hbl);
+
+    void LoadModule(CodeSet code_set, KProcessAddress base_addr);
+
+    Core::Memory::Memory& GetMemory() const;
+
+public:
+    // Overridden parent functions.
+    bool IsInitialized() const override {
+        return m_is_initialized;
+    }
+
+    static void PostDestroy(uintptr_t arg) {}
+
+    void Finalize() override;
+
+    u64 GetIdImpl() const {
+        return this->GetProcessId();
+    }
+    u64 GetId() const override {
+        return this->GetIdImpl();
+    }
+
+    virtual bool IsSignaled() const override {
+        ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));
+        return m_is_signaled;
+    }
+
+    void DoWorkerTaskImpl();
+
+private:
+    void ChangeState(State new_state) {
+        if (m_state != new_state) {
+            m_state = new_state;
+            m_is_signaled = true;
+            this->NotifyAvailable();
+        }
+    }
+
+    Result InitializeHandleTable(s32 size) {
+        // Try to initialize the handle table.
+        R_TRY(m_handle_table.Initialize(size));
+
+        // We succeeded, so note that we did.
+        m_is_handle_table_initialized = true;
+        R_SUCCEED();
+    }
+
     void FinalizeHandleTable() {
         // Finalize the table.
         m_handle_table.Finalize();
@@ -438,118 +534,6 @@ private:
         // Note that the table is finalized.
         m_is_handle_table_initialized = false;
     }
-
-    void ChangeState(State new_state);
-
-    /// Allocates the main thread stack for the process, given the stack size in bytes.
-    Result AllocateMainThreadStack(std::size_t stack_size);
-
-    /// Memory manager for this process
-    KPageTable m_page_table;
-
-    /// Current status of the process
-    State m_state{};
-
-    /// The ID of this process
-    u64 m_process_id = 0;
-
-    /// Title ID corresponding to the process
-    u64 m_program_id = 0;
-
-    /// Specifies additional memory to be reserved for the process's memory management by the
-    /// system. When this is non-zero, secure memory is allocated and used for page table allocation
-    /// instead of using the normal global page tables/memory block management.
-    u32 m_system_resource_size = 0;
-
-    /// Resource limit descriptor for this process
-    KResourceLimit* m_resource_limit{};
-
-    KVirtualAddress m_system_resource_address{};
-
-    /// The ideal CPU core for this process, threads are scheduled on this core by default.
-    u8 m_ideal_core = 0;
-
-    /// Contains the parsed process capability descriptors.
-    ProcessCapabilities m_capabilities;
-
-    /// Whether or not this process is AArch64, or AArch32.
-    /// By default, we currently assume this is true, unless otherwise
-    /// specified by metadata provided to the process during loading.
-    bool m_is_64bit_process = true;
-
-    /// Total running time for the process in ticks.
-    std::atomic<u64> m_total_process_running_time_ticks = 0;
-
-    /// Per-process handle table for storing created object handles in.
-    KHandleTable m_handle_table;
-
-    /// Per-process address arbiter.
-    KAddressArbiter m_address_arbiter;
-
-    /// The per-process mutex lock instance used for handling various
-    /// forms of services, such as lock arbitration, and condition
-    /// variable related facilities.
-    KConditionVariable m_condition_var;
-
-    /// Address indicating the location of the process' dedicated TLS region.
-    KProcessAddress m_plr_address = 0;
-
-    /// Address indicating the location of the process's entry point.
-    KProcessAddress m_code_address = 0;
-
-    /// Random values for svcGetInfo RandomEntropy
-    std::array<u64, RANDOM_ENTROPY_SIZE> m_random_entropy{};
-
-    /// List of threads that are running with this process as their owner.
-    std::list<KThread*> m_thread_list;
-
-    /// List of shared memory that are running with this process as their owner.
-    std::list<KSharedMemoryInfo*> m_shared_memory_list;
-
-    /// Address of the top of the main thread's stack
-    KProcessAddress m_main_thread_stack_top{};
-
-    /// Size of the main thread's stack
-    std::size_t m_main_thread_stack_size{};
-
-    /// Memory usage capacity for the process
-    std::size_t m_memory_usage_capacity{};
-
-    /// Process total image size
-    std::size_t m_image_size{};
-
-    /// Schedule count of this process
-    s64 m_schedule_count{};
-
-    size_t m_memory_release_hint{};
-
-    std::string name{};
-
-    bool m_is_signaled{};
-    bool m_is_suspended{};
-    bool m_is_immortal{};
-    bool m_is_handle_table_initialized{};
-    bool m_is_initialized{};
-    bool m_is_hbl{};
-
-    std::atomic<u16> m_num_running_threads{};
-
-    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{};
-    std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{};
-    std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_pinned_threads{};
-    std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{};
-    std::map<KProcessAddress, u64> m_debug_page_refcounts;
-
-    KThread* m_exception_thread{};
-
-    KLightLock m_state_lock;
-    KLightLock m_list_lock;
-
-    using TLPTree =
-        Common::IntrusiveRedBlackTreeBaseTraits<KThreadLocalPage>::TreeType<KThreadLocalPage>;
-    using TLPIterator = TLPTree::iterator;
-    TLPTree m_fully_used_tlp_tree;
-    TLPTree m_partially_used_tlp_tree;
 };
 
 } // namespace Kernel

src/core/hle/kernel/k_scheduler.cpp

@@ -190,7 +190,7 @@ u64 KScheduler::UpdateHighestPriorityThread(KThread* highest_thread) {
         if (m_state.should_count_idle) {
             if (highest_thread != nullptr) [[likely]] {
                 if (KProcess* process = highest_thread->GetOwnerProcess(); process != nullptr) {
-                    process->SetRunningThread(m_core_id, highest_thread, m_state.idle_count);
+                    process->SetRunningThread(m_core_id, highest_thread, m_state.idle_count, 0);
                 }
             } else {
                 m_state.idle_count++;
@@ -356,7 +356,7 @@ void KScheduler::SwitchThread(KThread* next_thread) {
     const s64 tick_diff = cur_tick - prev_tick;
     cur_thread->AddCpuTime(m_core_id, tick_diff);
     if (cur_process != nullptr) {
-        cur_process->UpdateCPUTimeTicks(tick_diff);
+        cur_process->AddCpuTime(tick_diff);
     }
     m_last_context_switch_time = cur_tick;
 

src/core/hle/kernel/k_system_resource.cpp

@@ -1,25 +1,100 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/core.h"
+#include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_system_resource.h"
 
 namespace Kernel {
 
 Result KSecureSystemResource::Initialize(size_t size, KResourceLimit* resource_limit,
                                          KMemoryManager::Pool pool) {
-    // Unimplemented
-    UNREACHABLE();
+    // Set members.
+    m_resource_limit = resource_limit;
+    m_resource_size = size;
+    m_resource_pool = pool;
+
+    // Determine required size for our secure resource.
+    const size_t secure_size = this->CalculateRequiredSecureMemorySize();
+
+    // Reserve memory for our secure resource.
+    KScopedResourceReservation memory_reservation(
+        m_resource_limit, Svc::LimitableResource::PhysicalMemoryMax, secure_size);
+    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
+
+    // Allocate secure memory.
+    R_TRY(KSystemControl::AllocateSecureMemory(m_kernel, std::addressof(m_resource_address),
+                                               m_resource_size, static_cast<u32>(m_resource_pool)));
+    ASSERT(m_resource_address != 0);
+
+    // Ensure we clean up the secure memory, if we fail past this point.
+    ON_RESULT_FAILURE {
+        KSystemControl::FreeSecureMemory(m_kernel, m_resource_address, m_resource_size,
+                                         static_cast<u32>(m_resource_pool));
+    };
+
+    // Check that our allocation is bigger than the reference counts needed for it.
+    const size_t rc_size =
+        Common::AlignUp(KPageTableSlabHeap::CalculateReferenceCountSize(m_resource_size), PageSize);
+    R_UNLESS(m_resource_size > rc_size, ResultOutOfMemory);
+
+    // Get resource pointer.
+    KPhysicalAddress resource_paddr =
+        KPageTable::GetHeapPhysicalAddress(m_kernel.MemoryLayout(), m_resource_address);
+    auto* resource =
+        m_kernel.System().DeviceMemory().GetPointer<KPageTableManager::RefCount>(resource_paddr);
+
+    // Initialize slab heaps.
+    m_dynamic_page_manager.Initialize(m_resource_address + rc_size, m_resource_size - rc_size,
+                                      PageSize);
+    m_page_table_heap.Initialize(std::addressof(m_dynamic_page_manager), 0, resource);
+    m_memory_block_heap.Initialize(std::addressof(m_dynamic_page_manager), 0);
+    m_block_info_heap.Initialize(std::addressof(m_dynamic_page_manager), 0);
+
+    // Initialize managers.
+    m_page_table_manager.Initialize(std::addressof(m_dynamic_page_manager),
+                                    std::addressof(m_page_table_heap));
+    m_memory_block_slab_manager.Initialize(std::addressof(m_dynamic_page_manager),
+                                           std::addressof(m_memory_block_heap));
+    m_block_info_manager.Initialize(std::addressof(m_dynamic_page_manager),
+                                    std::addressof(m_block_info_heap));
+
+    // Set our managers.
+    this->SetManagers(m_memory_block_slab_manager, m_block_info_manager, m_page_table_manager);
+
+    // Commit the memory reservation.
+    memory_reservation.Commit();
+
+    // Open reference to our resource limit.
+    m_resource_limit->Open();
+
+    // Set ourselves as initialized.
+    m_is_initialized = true;
+
+    R_SUCCEED();
 }
 
 void KSecureSystemResource::Finalize() {
-    // Unimplemented
-    UNREACHABLE();
+    // Check that we have no outstanding allocations.
+    ASSERT(m_memory_block_slab_manager.GetUsed() == 0);
+    ASSERT(m_block_info_manager.GetUsed() == 0);
+    ASSERT(m_page_table_manager.GetUsed() == 0);
+
+    // Free our secure memory.
+    KSystemControl::FreeSecureMemory(m_kernel, m_resource_address, m_resource_size,
+                                     static_cast<u32>(m_resource_pool));
+
+    // Release the memory reservation.
+    m_resource_limit->Release(Svc::LimitableResource::PhysicalMemoryMax,
+                              this->CalculateRequiredSecureMemorySize());
+
+    // Close reference to our resource limit.
+    m_resource_limit->Close();
 }
 
 size_t KSecureSystemResource::CalculateRequiredSecureMemorySize(size_t size,
                                                                 KMemoryManager::Pool pool) {
-    // Unimplemented
-    UNREACHABLE();
+    return KSystemControl::CalculateRequiredSecureMemorySize(size, static_cast<u32>(pool));
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_thread.cpp

@@ -122,16 +122,15 @@ Result KThread::Initialize(KThreadFunction func, uintptr_t arg, KProcessAddress
     case ThreadType::Main:
         ASSERT(arg == 0);
         [[fallthrough]];
-    case ThreadType::HighPriority:
-        [[fallthrough]];
-    case ThreadType::Dummy:
-        [[fallthrough]];
     case ThreadType::User:
         ASSERT(((owner == nullptr) ||
                 (owner->GetCoreMask() | (1ULL << virt_core)) == owner->GetCoreMask()));
         ASSERT(((owner == nullptr) || (prio > Svc::LowestThreadPriority) ||
                 (owner->GetPriorityMask() | (1ULL << prio)) == owner->GetPriorityMask()));
         break;
+    case ThreadType::HighPriority:
+    case ThreadType::Dummy:
+        break;
     case ThreadType::Kernel:
         UNIMPLEMENTED();
         break;
@@ -216,6 +215,7 @@ Result KThread::Initialize(KThreadFunction func, uintptr_t arg, KProcessAddress
         // Setup the TLS, if needed.
         if (type == ThreadType::User) {
             R_TRY(owner->CreateThreadLocalRegion(std::addressof(m_tls_address)));
+            owner->GetMemory().ZeroBlock(m_tls_address, Svc::ThreadLocalRegionSize);
         }
 
         m_parent = owner;
@@ -403,7 +403,7 @@ void KThread::StartTermination() {
     if (m_parent != nullptr) {
         m_parent->ReleaseUserException(this);
         if (m_parent->GetPinnedThread(GetCurrentCoreId(m_kernel)) == this) {
-            m_parent->UnpinCurrentThread(m_core_id);
+            m_parent->UnpinCurrentThread();
         }
     }
 
@@ -415,10 +415,6 @@ void KThread::StartTermination() {
         m_parent->ClearRunningThread(this);
     }
 
-    // Signal.
-    m_signaled = true;
-    KSynchronizationObject::NotifyAvailable();
-
     // Clear previous thread in KScheduler.
     KScheduler::ClearPreviousThread(m_kernel, this);
 
@@ -437,6 +433,13 @@ void KThread::FinishTermination() {
         }
     }
 
+    // Acquire the scheduler lock.
+    KScopedSchedulerLock sl{m_kernel};
+
+    // Signal.
+    m_signaled = true;
+    KSynchronizationObject::NotifyAvailable();
+
     // Close the thread.
     this->Close();
 }
@@ -820,7 +823,7 @@ void KThread::CloneFpuStatus() {
     ASSERT(this->GetOwnerProcess() != nullptr);
     ASSERT(this->GetOwnerProcess() == GetCurrentProcessPointer(m_kernel));
 
-    if (this->GetOwnerProcess()->Is64BitProcess()) {
+    if (this->GetOwnerProcess()->Is64Bit()) {
         // Clone FPSR and FPCR.
         ThreadContext64 cur_ctx{};
         m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx);
@@ -923,7 +926,7 @@ Result KThread::GetThreadContext3(Common::ScratchBuffer<u8>& out) {
 
         // If we're not terminating, get the thread's user context.
         if (!this->IsTerminationRequested()) {
-            if (m_parent->Is64BitProcess()) {
+            if (m_parent->Is64Bit()) {
                 // Mask away mode bits, interrupt bits, IL bit, and other reserved bits.
                 auto context = GetContext64();
                 context.pstate &= 0xFF0FFE20;
@@ -1174,6 +1177,9 @@ Result KThread::Run() {
             owner->IncrementRunningThreadCount();
         }
 
+        // Open a reference, now that we're running.
+        this->Open();
+
         // Set our state and finish.
         this->SetState(ThreadState::Runnable);
 

src/core/hle/kernel/k_thread.h

@@ -721,6 +721,7 @@ private:
     // For core KThread implementation
     ThreadContext32 m_thread_context_32{};
     ThreadContext64 m_thread_context_64{};
+    Common::IntrusiveListNode m_process_list_node;
     Common::IntrusiveRedBlackTreeNode m_condvar_arbiter_tree_node{};
     s32 m_priority{};
     using ConditionVariableThreadTreeTraits =

src/core/hle/kernel/kernel.cpp

@@ -101,35 +101,31 @@ struct KernelCore::Impl {
 
     void InitializeCores() {
         for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            cores[core_id]->Initialize((*application_process).Is64BitProcess());
+            cores[core_id]->Initialize((*application_process).Is64Bit());
             system.ApplicationMemory().SetCurrentPageTable(*application_process, core_id);
         }
     }
 
-    void CloseApplicationProcess() {
-        KProcess* old_process = application_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.
-        old_process->Finalize();
-        old_process->Destroy();
+    void TerminateApplicationProcess() {
+        application_process.load()->Terminate();
     }
 
     void Shutdown() {
         is_shutting_down.store(true, std::memory_order_relaxed);
         SCOPE_EXIT({ is_shutting_down.store(false, std::memory_order_relaxed); });
 
-        process_list.clear();
-
         CloseServices();
 
+        auto* old_process = application_process.exchange(nullptr);
+        if (old_process) {
+            old_process->Close();
+        }
+
+        process_list.clear();
+
         next_object_id = 0;
-        next_kernel_process_id = KProcess::InitialKIPIDMin;
-        next_user_process_id = KProcess::ProcessIDMin;
+        next_kernel_process_id = KProcess::InitialProcessIdMin;
+        next_user_process_id = KProcess::ProcessIdMin;
         next_thread_id = 1;
 
         global_handle_table->Finalize();
@@ -176,8 +172,6 @@ struct KernelCore::Impl {
             }
         }
 
-        CloseApplicationProcess();
-
         // Track kernel objects that were not freed on shutdown
         {
             std::scoped_lock lk{registered_objects_lock};
@@ -344,6 +338,8 @@ struct KernelCore::Impl {
         // Create the system page table managers.
         app_system_resource = std::make_unique<KSystemResource>(kernel);
         sys_system_resource = std::make_unique<KSystemResource>(kernel);
+        KAutoObject::Create(std::addressof(*app_system_resource));
+        KAutoObject::Create(std::addressof(*sys_system_resource));
 
         // Set the managers for the system resources.
         app_system_resource->SetManagers(*app_memory_block_manager, *app_block_info_manager,
@@ -792,8 +788,8 @@ struct KernelCore::Impl {
     std::mutex registered_in_use_objects_lock;
 
     std::atomic<u32> next_object_id{0};
-    std::atomic<u64> next_kernel_process_id{KProcess::InitialKIPIDMin};
-    std::atomic<u64> next_user_process_id{KProcess::ProcessIDMin};
+    std::atomic<u64> next_kernel_process_id{KProcess::InitialProcessIdMin};
+    std::atomic<u64> next_user_process_id{KProcess::ProcessIdMin};
     std::atomic<u64> next_thread_id{1};
 
     // Lists all processes that exist in the current session.
@@ -924,10 +920,6 @@ const KProcess* KernelCore::ApplicationProcess() const {
     return impl->application_process;
 }
 
-void KernelCore::CloseApplicationProcess() {
-    impl->CloseApplicationProcess();
-}
-
 const std::vector<KProcess*>& KernelCore::GetProcessList() const {
     return impl->process_list;
 }
@@ -1128,8 +1120,8 @@ std::jthread KernelCore::RunOnHostCoreProcess(std::string&& process_name,
                                               std::function<void()> func) {
     // Make a new process.
     KProcess* process = KProcess::Create(*this);
-    ASSERT(R_SUCCEEDED(KProcess::Initialize(process, System(), "", KProcess::ProcessType::Userland,
-                                            GetSystemResourceLimit())));
+    ASSERT(R_SUCCEEDED(
+        process->Initialize(Svc::CreateProcessParameter{}, GetSystemResourceLimit(), false)));
 
     // Ensure that we don't hold onto any extra references.
     SCOPE_EXIT({ process->Close(); });
@@ -1156,8 +1148,8 @@ void KernelCore::RunOnGuestCoreProcess(std::string&& process_name, std::function
 
     // Make a new process.
     KProcess* process = KProcess::Create(*this);
-    ASSERT(R_SUCCEEDED(KProcess::Initialize(process, System(), "", KProcess::ProcessType::Userland,
-                                            GetSystemResourceLimit())));
+    ASSERT(R_SUCCEEDED(
+        process->Initialize(Svc::CreateProcessParameter{}, GetSystemResourceLimit(), false)));
 
     // Ensure that we don't hold onto any extra references.
     SCOPE_EXIT({ process->Close(); });
@@ -1266,7 +1258,8 @@ const Kernel::KSharedMemory& KernelCore::GetHidBusSharedMem() const {
 
 void KernelCore::SuspendApplication(bool suspended) {
     const bool should_suspend{exception_exited || suspended};
-    const auto activity = should_suspend ? ProcessActivity::Paused : ProcessActivity::Runnable;
+    const auto activity =
+        should_suspend ? Svc::ProcessActivity::Paused : Svc::ProcessActivity::Runnable;
 
     // Get the application process.
     KScopedAutoObject<KProcess> process = ApplicationProcess();
@@ -1300,6 +1293,8 @@ void KernelCore::SuspendApplication(bool suspended) {
 }
 
 void KernelCore::ShutdownCores() {
+    impl->TerminateApplicationProcess();
+
     KScopedSchedulerLock lk{*this};
 
     for (auto* thread : impl->shutdown_threads) {

src/core/hle/kernel/kernel.h

@@ -134,9 +134,6 @@ public:
     /// Retrieves a const pointer to the application process.
     const KProcess* ApplicationProcess() const;
 
-    /// Closes the application process.
-    void CloseApplicationProcess();
-
     /// Retrieves the list of processes.
     const std::vector<KProcess*>& GetProcessList() const;
 

src/core/hle/kernel/svc.cpp

@@ -4426,7 +4426,7 @@ void Call(Core::System& system, u32 imm) {
     auto& kernel = system.Kernel();
     kernel.EnterSVCProfile();
 
-    if (GetCurrentProcess(system.Kernel()).Is64BitProcess()) {
+    if (GetCurrentProcess(system.Kernel()).Is64Bit()) {
         Call64(system, imm);
     } else {
         Call32(system, imm);

src/core/hle/kernel/svc/svc_info.cpp

@@ -86,20 +86,19 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
             R_SUCCEED();
 
         case InfoType::TotalMemorySize:
-            *result = process->GetTotalPhysicalMemoryAvailable();
+            *result = process->GetTotalUserPhysicalMemorySize();
             R_SUCCEED();
 
         case InfoType::UsedMemorySize:
-            *result = process->GetTotalPhysicalMemoryUsed();
+            *result = process->GetUsedUserPhysicalMemorySize();
             R_SUCCEED();
 
         case InfoType::SystemResourceSizeTotal:
-            *result = process->GetSystemResourceSize();
+            *result = process->GetTotalSystemResourceSize();
             R_SUCCEED();
 
         case InfoType::SystemResourceSizeUsed:
-            LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query system resource usage");
-            *result = process->GetSystemResourceUsage();
+            *result = process->GetUsedSystemResourceSize();
             R_SUCCEED();
 
         case InfoType::ProgramId:
@@ -111,20 +110,29 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
             R_SUCCEED();
 
         case InfoType::TotalNonSystemMemorySize:
-            *result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();
+            *result = process->GetTotalNonSystemUserPhysicalMemorySize();
             R_SUCCEED();
 
         case InfoType::UsedNonSystemMemorySize:
-            *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
+            *result = process->GetUsedNonSystemUserPhysicalMemorySize();
             R_SUCCEED();
 
         case InfoType::IsApplication:
             LOG_WARNING(Kernel_SVC, "(STUBBED) Assuming process is application");
-            *result = true;
+            *result = process->IsApplication();
             R_SUCCEED();
 
         case InfoType::FreeThreadCount:
-            *result = process->GetFreeThreadCount();
+            if (KResourceLimit* resource_limit = process->GetResourceLimit();
+                resource_limit != nullptr) {
+                const auto current_value =
+                    resource_limit->GetCurrentValue(Svc::LimitableResource::ThreadCountMax);
+                const auto limit_value =
+                    resource_limit->GetLimitValue(Svc::LimitableResource::ThreadCountMax);
+                *result = limit_value - current_value;
+            } else {
+                *result = 0;
+            }
             R_SUCCEED();
 
         default:
@@ -161,7 +169,7 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
 
     case InfoType::RandomEntropy:
         R_UNLESS(handle == 0, ResultInvalidHandle);
-        R_UNLESS(info_sub_id < KProcess::RANDOM_ENTROPY_SIZE, ResultInvalidCombination);
+        R_UNLESS(info_sub_id < 4, ResultInvalidCombination);
 
         *result = GetCurrentProcess(system.Kernel()).GetRandomEntropy(info_sub_id);
         R_SUCCEED();

src/core/hle/kernel/svc/svc_lock.cpp

@@ -17,7 +17,7 @@ Result ArbitrateLock(Core::System& system, Handle thread_handle, u64 address, u3
     R_UNLESS(!IsKernelAddress(address), ResultInvalidCurrentMemory);
     R_UNLESS(Common::IsAligned(address, sizeof(u32)), ResultInvalidAddress);
 
-    R_RETURN(GetCurrentProcess(system.Kernel()).WaitForAddress(thread_handle, address, tag));
+    R_RETURN(KConditionVariable::WaitForAddress(system.Kernel(), thread_handle, address, tag));
 }
 
 /// Unlock a mutex
@@ -28,7 +28,7 @@ Result ArbitrateUnlock(Core::System& system, u64 address) {
     R_UNLESS(!IsKernelAddress(address), ResultInvalidCurrentMemory);
     R_UNLESS(Common::IsAligned(address, sizeof(u32)), ResultInvalidAddress);
 
-    R_RETURN(GetCurrentProcess(system.Kernel()).SignalToAddress(address));
+    R_RETURN(KConditionVariable::SignalToAddress(system.Kernel(), address));
 }
 
 Result ArbitrateLock64(Core::System& system, Handle thread_handle, uint64_t address, uint32_t tag) {

src/core/hle/kernel/svc/svc_physical_memory.cpp

@@ -46,7 +46,7 @@ Result MapPhysicalMemory(Core::System& system, u64 addr, u64 size) {
     KProcess* const current_process{GetCurrentProcessPointer(system.Kernel())};
     auto& page_table{current_process->GetPageTable()};
 
-    if (current_process->GetSystemResourceSize() == 0) {
+    if (current_process->GetTotalSystemResourceSize() == 0) {
         LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
         R_THROW(ResultInvalidState);
     }
@@ -95,7 +95,7 @@ Result UnmapPhysicalMemory(Core::System& system, u64 addr, u64 size) {
     KProcess* const current_process{GetCurrentProcessPointer(system.Kernel())};
     auto& page_table{current_process->GetPageTable()};
 
-    if (current_process->GetSystemResourceSize() == 0) {
+    if (current_process->GetTotalSystemResourceSize() == 0) {
         LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
         R_THROW(ResultInvalidState);
     }

src/core/hle/kernel/svc/svc_synchronization.cpp

@@ -132,7 +132,7 @@ void SynchronizePreemptionState(Core::System& system) {
         GetCurrentThread(kernel).ClearInterruptFlag();
 
         // Unpin the current thread.
-        cur_process->UnpinCurrentThread(core_id);
+        cur_process->UnpinCurrentThread();
     }
 }
 

src/core/hle/kernel/svc/svc_thread.cpp

@@ -85,10 +85,6 @@ Result StartThread(Core::System& system, Handle thread_handle) {
     // Try to start the thread.
     R_TRY(thread->Run());
 
-    // If we succeeded, persist a reference to the thread.
-    thread->Open();
-    system.Kernel().RegisterInUseObject(thread.GetPointerUnsafe());
-
     R_SUCCEED();
 }
 
@@ -99,7 +95,6 @@ void ExitThread(Core::System& system) {
     auto* const current_thread = GetCurrentThreadPointer(system.Kernel());
     system.GlobalSchedulerContext().RemoveThread(current_thread);
     current_thread->Exit();
-    system.Kernel().UnregisterInUseObject(current_thread);
 }
 
 /// Sleep the current thread
@@ -260,7 +255,7 @@ Result GetThreadList(Core::System& system, s32* out_num_threads, u64 out_thread_
 
     auto list_iter = thread_list.cbegin();
     for (std::size_t i = 0; i < copy_amount; ++i, ++list_iter) {
-        memory.Write64(out_thread_ids, (*list_iter)->GetThreadId());
+        memory.Write64(out_thread_ids, list_iter->GetThreadId());
         out_thread_ids += sizeof(u64);
     }
 

src/core/hle/kernel/svc_generator.py

@@ -592,7 +592,7 @@ void Call(Core::System& system, u32 imm) {
     auto& kernel = system.Kernel();
     kernel.EnterSVCProfile();
 
-    if (GetCurrentProcess(system.Kernel()).Is64BitProcess()) {
+    if (GetCurrentProcess(system.Kernel()).Is64Bit()) {
         Call64(system, imm);
     } else {
         Call32(system, imm);

src/core/hle/kernel/svc_types.h

@@ -604,13 +604,57 @@ enum class ProcessActivity : u32 {
     Paused,
 };
 
+enum class CreateProcessFlag : u32 {
+    // Is 64 bit?
+    Is64Bit = (1 << 0),
+
+    // What kind of address space?
+    AddressSpaceShift = 1,
+    AddressSpaceMask = (7 << AddressSpaceShift),
+    AddressSpace32Bit = (0 << AddressSpaceShift),
+    AddressSpace64BitDeprecated = (1 << AddressSpaceShift),
+    AddressSpace32BitWithoutAlias = (2 << AddressSpaceShift),
+    AddressSpace64Bit = (3 << AddressSpaceShift),
+
+    // Should JIT debug be done on crash?
+    EnableDebug = (1 << 4),
+
+    // Should ASLR be enabled for the process?
+    EnableAslr = (1 << 5),
+
+    // Is the process an application?
+    IsApplication = (1 << 6),
+
+    // 4.x deprecated: Should use secure memory?
+    DeprecatedUseSecureMemory = (1 << 7),
+
+    // 5.x+ Pool partition type.
+    PoolPartitionShift = 7,
+    PoolPartitionMask = (0xF << PoolPartitionShift),
+    PoolPartitionApplication = (0 << PoolPartitionShift),
+    PoolPartitionApplet = (1 << PoolPartitionShift),
+    PoolPartitionSystem = (2 << PoolPartitionShift),
+    PoolPartitionSystemNonSecure = (3 << PoolPartitionShift),
+
+    // 7.x+ Should memory allocation be optimized? This requires IsApplication.
+    OptimizeMemoryAllocation = (1 << 11),
+
+    // 11.x+ DisableDeviceAddressSpaceMerge.
+    DisableDeviceAddressSpaceMerge = (1 << 12),
+
+    // Mask of all flags.
+    All = Is64Bit | AddressSpaceMask | EnableDebug | EnableAslr | IsApplication |
+          PoolPartitionMask | OptimizeMemoryAllocation | DisableDeviceAddressSpaceMerge,
+};
+DECLARE_ENUM_FLAG_OPERATORS(CreateProcessFlag);
+
 struct CreateProcessParameter {
     std::array<char, 12> name;
     u32 version;
     u64 program_id;
     u64 code_address;
     s32 code_num_pages;
-    u32 flags;
+    CreateProcessFlag flags;
     Handle reslimit;
     s32 system_resource_num_pages;
 };

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

@@ -796,7 +796,9 @@ ILockAccessor::ILockAccessor(Core::System& system_)
     lock_event = service_context.CreateEvent("ILockAccessor::LockEvent");
 }
 
-ILockAccessor::~ILockAccessor() = default;
+ILockAccessor::~ILockAccessor() {
+    service_context.CloseEvent(lock_event);
+};
 
 void ILockAccessor::TryLock(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
@@ -909,7 +911,9 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_,
     msg_queue->PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoForeground);
 }
 
-ICommonStateGetter::~ICommonStateGetter() = default;
+ICommonStateGetter::~ICommonStateGetter() {
+    service_context.CloseEvent(sleep_lock_event);
+};
 
 void ICommonStateGetter::GetBootMode(HLERequestContext& ctx) {
     LOG_DEBUG(Service_AM, "called");

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

@@ -25,7 +25,9 @@ Cabinet::Cabinet(Core::System& system_, LibraryAppletMode applet_mode_,
         service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent");
 }
 
-Cabinet::~Cabinet() = default;
+Cabinet::~Cabinet() {
+    service_context.CloseEvent(availability_change_event);
+};
 
 void Cabinet::Initialize() {
     Applet::Initialize();

src/core/hle/service/caps/caps.cpp

@@ -25,11 +25,12 @@ void LoopProcess(Core::System& system) {
     server_manager->RegisterNamedService(
         "caps:u", std::make_shared<IAlbumApplicationService>(system, album_manager));
 
-    server_manager->RegisterNamedService("caps:ss", std::make_shared<IScreenShotService>(system));
+    server_manager->RegisterNamedService(
+        "caps:ss", std::make_shared<IScreenShotService>(system, album_manager));
     server_manager->RegisterNamedService("caps:sc",
                                          std::make_shared<IScreenShotControlService>(system));
-    server_manager->RegisterNamedService("caps:su",
-                                         std::make_shared<IScreenShotApplicationService>(system));
+    server_manager->RegisterNamedService(
+        "caps:su", std::make_shared<IScreenShotApplicationService>(system, album_manager));
 
     ServerManager::RunServer(std::move(server_manager));
 }

src/core/hle/service/caps/caps_manager.cpp

@@ -2,12 +2,11 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <sstream>
-#include <stb_image.h>
-#include <stb_image_resize.h>
 
 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
+#include "common/stb.h"
 #include "core/core.h"
 #include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_result.h"
@@ -227,6 +226,49 @@ Result AlbumManager::LoadAlbumScreenShotThumbnail(
                      +static_cast<int>(out_image_output.height), decoder_options.flags);
 }
 
+Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
+                                    const ScreenShotAttribute& attribute,
+                                    std::span<const u8> image_data, u64 aruid) {
+    return SaveScreenShot(out_entry, attribute, {}, image_data, aruid);
+}
+
+Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
+                                    const ScreenShotAttribute& attribute,
+                                    const ApplicationData& app_data, std::span<const u8> image_data,
+                                    u64 aruid) {
+    const u64 title_id = system.GetApplicationProcessProgramID();
+    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
+
+    s64 posix_time{};
+    Result result = user_clock.GetCurrentTime(system, posix_time);
+
+    if (result.IsError()) {
+        return result;
+    }
+
+    const auto date = ConvertToAlbumDateTime(posix_time);
+
+    return SaveImage(out_entry, image_data, title_id, date);
+}
+
+Result AlbumManager::SaveEditedScreenShot(ApplicationAlbumEntry& out_entry,
+                                          const ScreenShotAttribute& attribute,
+                                          const AlbumFileId& file_id,
+                                          std::span<const u8> image_data) {
+    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
+
+    s64 posix_time{};
+    Result result = user_clock.GetCurrentTime(system, posix_time);
+
+    if (result.IsError()) {
+        return result;
+    }
+
+    const auto date = ConvertToAlbumDateTime(posix_time);
+
+    return SaveImage(out_entry, image_data, file_id.application_id, date);
+}
+
 Result AlbumManager::GetFile(std::filesystem::path& out_path, const AlbumFileId& file_id) const {
     const auto file = album_files.find(file_id);
 
@@ -365,6 +407,47 @@ Result AlbumManager::LoadImage(std::span<u8> out_image, const std::filesystem::p
     return ResultSuccess;
 }
 
+static void PNGToMemory(void* context, void* png, int len) {
+    std::vector<u8>* png_image = static_cast<std::vector<u8>*>(context);
+    png_image->reserve(len);
+    std::memcpy(png_image->data(), png, len);
+}
+
+Result AlbumManager::SaveImage(ApplicationAlbumEntry& out_entry, std::span<const u8> image,
+                               u64 title_id, const AlbumFileDateTime& date) const {
+    const auto screenshot_path =
+        Common::FS::GetYuzuPathString(Common::FS::YuzuPath::ScreenshotsDir);
+    const std::string formatted_date =
+        fmt::format("{:04}-{:02}-{:02}_{:02}-{:02}-{:02}-{:03}", date.year, date.month, date.day,
+                    date.hour, date.minute, date.second, 0);
+    const std::string file_path =
+        fmt::format("{}/{:016x}_{}.png", screenshot_path, title_id, formatted_date);
+
+    const Common::FS::IOFile db_file{file_path, Common::FS::FileAccessMode::Write,
+                                     Common::FS::FileType::BinaryFile};
+
+    std::vector<u8> png_image;
+    if (!stbi_write_png_to_func(PNGToMemory, &png_image, 1280, 720, STBI_rgb_alpha, image.data(),
+                                0)) {
+        return ResultFileCountLimit;
+    }
+
+    if (db_file.Write(png_image) != png_image.size()) {
+        return ResultFileCountLimit;
+    }
+
+    out_entry = {
+        .size = png_image.size(),
+        .hash = {},
+        .datetime = date,
+        .storage = AlbumStorage::Sd,
+        .content = ContentType::Screenshot,
+        .unknown = 1,
+    };
+
+    return ResultSuccess;
+}
+
 AlbumFileDateTime AlbumManager::ConvertToAlbumDateTime(u64 posix_time) const {
     Time::TimeZone::CalendarInfo calendar_date{};
     const auto& time_zone_manager =

src/core/hle/service/caps/caps_manager.h

@@ -58,6 +58,15 @@ public:
                                         std::vector<u8>& out_image, const AlbumFileId& file_id,
                                         const ScreenShotDecodeOption& decoder_options) const;
 
+    Result SaveScreenShot(ApplicationAlbumEntry& out_entry, const ScreenShotAttribute& attribute,
+                          std::span<const u8> image_data, u64 aruid);
+    Result SaveScreenShot(ApplicationAlbumEntry& out_entry, const ScreenShotAttribute& attribute,
+                          const ApplicationData& app_data, std::span<const u8> image_data,
+                          u64 aruid);
+    Result SaveEditedScreenShot(ApplicationAlbumEntry& out_entry,
+                                const ScreenShotAttribute& attribute, const AlbumFileId& file_id,
+                                std::span<const u8> image_data);
+
 private:
     static constexpr std::size_t NandAlbumFileLimit = 1000;
     static constexpr std::size_t SdAlbumFileLimit = 10000;
@@ -67,6 +76,8 @@ private:
     Result GetAlbumEntry(AlbumEntry& out_entry, const std::filesystem::path& path) const;
     Result LoadImage(std::span<u8> out_image, const std::filesystem::path& path, int width,
                      int height, ScreenShotDecoderFlag flag) const;
+    Result SaveImage(ApplicationAlbumEntry& out_entry, std::span<const u8> image, u64 title_id,
+                     const AlbumFileDateTime& date) const;
 
     AlbumFileDateTime ConvertToAlbumDateTime(u64 posix_time) const;
 

src/core/hle/service/caps/caps_ss.cpp

@@ -1,19 +1,25 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/logging/log.h"
+#include "core/hle/service/caps/caps_manager.h"
+#include "core/hle/service/caps/caps_types.h"
+#include "core/hle/service/ipc_helpers.h"
+
 #include "core/hle/service/caps/caps_ss.h"
 
 namespace Service::Capture {
 
-IScreenShotService::IScreenShotService(Core::System& system_)
-    : ServiceFramework{system_, "caps:ss"} {
+IScreenShotService::IScreenShotService(Core::System& system_,
+                                       std::shared_ptr<AlbumManager> album_manager)
+    : ServiceFramework{system_, "caps:ss"}, manager{album_manager} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {201, nullptr, "SaveScreenShot"},
         {202, nullptr, "SaveEditedScreenShot"},
-        {203, nullptr, "SaveScreenShotEx0"},
+        {203, &IScreenShotService::SaveScreenShotEx0, "SaveScreenShotEx0"},
         {204, nullptr, "SaveEditedScreenShotEx0"},
-        {206, nullptr, "Unknown206"},
+        {206, &IScreenShotService::SaveEditedScreenShotEx1, "SaveEditedScreenShotEx1"},
         {208, nullptr, "SaveScreenShotOfMovieEx1"},
         {1000, nullptr, "Unknown1000"},
     };
@@ -24,4 +30,65 @@ IScreenShotService::IScreenShotService(Core::System& system_)
 
 IScreenShotService::~IScreenShotService() = default;
 
+void IScreenShotService::SaveScreenShotEx0(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        ScreenShotAttribute attribute{};
+        u32 report_option{};
+        INSERT_PADDING_BYTES(0x4);
+        u64 applet_resource_user_id{};
+    };
+    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+    const auto image_data_buffer = ctx.ReadBuffer();
+
+    LOG_INFO(Service_Capture,
+             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
+             parameters.report_option, image_data_buffer.size(),
+             parameters.applet_resource_user_id);
+
+    ApplicationAlbumEntry entry{};
+    const auto result = manager->SaveScreenShot(entry, parameters.attribute, image_data_buffer,
+                                                parameters.applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 10};
+    rb.Push(result);
+    rb.PushRaw(entry);
+}
+void IScreenShotService::SaveEditedScreenShotEx1(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        ScreenShotAttribute attribute;
+        u64 width;
+        u64 height;
+        u64 thumbnail_width;
+        u64 thumbnail_height;
+        AlbumFileId file_id;
+    };
+    static_assert(sizeof(Parameters) == 0x78, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+    const auto application_data_buffer = ctx.ReadBuffer(0);
+    const auto image_data_buffer = ctx.ReadBuffer(1);
+    const auto thumbnail_image_data_buffer = ctx.ReadBuffer(2);
+
+    LOG_INFO(Service_Capture,
+             "called, width={}, height={}, thumbnail_width={}, thumbnail_height={}, "
+             "application_id={:016x},  storage={},  type={}, app_data_buffer_size={}, "
+             "image_data_buffer_size={}, thumbnail_image_buffer_size={}",
+             parameters.width, parameters.height, parameters.thumbnail_width,
+             parameters.thumbnail_height, parameters.file_id.application_id,
+             parameters.file_id.storage, parameters.file_id.type, application_data_buffer.size(),
+             image_data_buffer.size(), thumbnail_image_data_buffer.size());
+
+    ApplicationAlbumEntry entry{};
+    const auto result = manager->SaveEditedScreenShot(entry, parameters.attribute,
+                                                      parameters.file_id, image_data_buffer);
+
+    IPC::ResponseBuilder rb{ctx, 10};
+    rb.Push(result);
+    rb.PushRaw(entry);
+}
+
 } // namespace Service::Capture

src/core/hle/service/caps/caps_ss.h

@@ -13,8 +13,14 @@ namespace Service::Capture {
 
 class IScreenShotService final : public ServiceFramework<IScreenShotService> {
 public:
-    explicit IScreenShotService(Core::System& system_);
+    explicit IScreenShotService(Core::System& system_, std::shared_ptr<AlbumManager> album_manager);
     ~IScreenShotService() override;
+
+private:
+    void SaveScreenShotEx0(HLERequestContext& ctx);
+    void SaveEditedScreenShotEx1(HLERequestContext& ctx);
+
+    std::shared_ptr<AlbumManager> manager;
 };
 
 } // namespace Service::Capture

src/core/hle/service/caps/caps_su.cpp

@@ -2,19 +2,22 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/logging/log.h"
+#include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_su.h"
+#include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Capture {
 
-IScreenShotApplicationService::IScreenShotApplicationService(Core::System& system_)
-    : ServiceFramework{system_, "caps:su"} {
+IScreenShotApplicationService::IScreenShotApplicationService(
+    Core::System& system_, std::shared_ptr<AlbumManager> album_manager)
+    : ServiceFramework{system_, "caps:su"}, manager{album_manager} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {32, &IScreenShotApplicationService::SetShimLibraryVersion, "SetShimLibraryVersion"},
         {201, nullptr, "SaveScreenShot"},
-        {203, nullptr, "SaveScreenShotEx0"},
-        {205, nullptr, "SaveScreenShotEx1"},
+        {203, &IScreenShotApplicationService::SaveScreenShotEx0, "SaveScreenShotEx0"},
+        {205, &IScreenShotApplicationService::SaveScreenShotEx1, "SaveScreenShotEx1"},
         {210, nullptr, "SaveScreenShotEx2"},
     };
     // clang-format on
@@ -36,4 +39,62 @@ void IScreenShotApplicationService::SetShimLibraryVersion(HLERequestContext& ctx
     rb.Push(ResultSuccess);
 }
 
+void IScreenShotApplicationService::SaveScreenShotEx0(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        ScreenShotAttribute attribute{};
+        AlbumReportOption report_option{};
+        INSERT_PADDING_BYTES(0x4);
+        u64 applet_resource_user_id{};
+    };
+    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+    const auto image_data_buffer = ctx.ReadBuffer();
+
+    LOG_INFO(Service_Capture,
+             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
+             parameters.report_option, image_data_buffer.size(),
+             parameters.applet_resource_user_id);
+
+    ApplicationAlbumEntry entry{};
+    const auto result = manager->SaveScreenShot(entry, parameters.attribute, image_data_buffer,
+                                                parameters.applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 10};
+    rb.Push(result);
+    rb.PushRaw(entry);
+}
+
+void IScreenShotApplicationService::SaveScreenShotEx1(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        ScreenShotAttribute attribute{};
+        AlbumReportOption report_option{};
+        INSERT_PADDING_BYTES(0x4);
+        u64 applet_resource_user_id{};
+    };
+    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
+
+    const auto parameters{rp.PopRaw<Parameters>()};
+    const auto app_data_buffer = ctx.ReadBuffer(0);
+    const auto image_data_buffer = ctx.ReadBuffer(1);
+
+    LOG_INFO(Service_Capture,
+             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
+             parameters.report_option, image_data_buffer.size(),
+             parameters.applet_resource_user_id);
+
+    ApplicationAlbumEntry entry{};
+    ApplicationData app_data{};
+    std::memcpy(&app_data, app_data_buffer.data(), sizeof(ApplicationData));
+    const auto result =
+        manager->SaveScreenShot(entry, parameters.attribute, app_data, image_data_buffer,
+                                parameters.applet_resource_user_id);
+
+    IPC::ResponseBuilder rb{ctx, 10};
+    rb.Push(result);
+    rb.PushRaw(entry);
+}
+
 } // namespace Service::Capture