Reaper: Set minimum cleaning limit on OGL.

WIP

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

@@ -9,11 +9,5 @@ cp "${REV_NAME}-source.tar.xz" "$DIR_NAME"
 
 tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$DIR_NAME"
 
-mv "$DIR_NAME" $RELEASE_NAME
-mv "${REV_NAME}-source.tar.xz" $RELEASE_NAME
-
-7z a "$REV_NAME.7z" $RELEASE_NAME
-
 # move the compiled archive into the artifacts directory to be uploaded by travis releases
 mv "$ARCHIVE_NAME" "${ARTIFACTS_DIR}/"
-mv "$REV_NAME.7z" "${ARTIFACTS_DIR}/"

.ci/scripts/windows/docker.sh

@@ -47,3 +47,6 @@ python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"
 EXTERNALS_PATH="$(pwd)/build/externals"
 FFMPEG_DLL_PATH="$(find ${EXTERNALS_PATH} -maxdepth 1 -type d | grep ffmpeg)/bin"
 find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -v {} package/ ';'
+
+# copy libraries from yuzu.exe path
+find "$(pwd)/build/bin/" -type f -regex ".*\.dll" -exec cp -v {} package/ ';'

.ci/scripts/windows/upload.sh

@@ -3,8 +3,8 @@
 . .ci/scripts/common/pre-upload.sh
 
 REV_NAME="yuzu-windows-mingw-${GITDATE}-${GITREV}"
-ARCHIVE_NAME="${REV_NAME}.tar.gz"
-COMPRESSION_FLAGS="-czvf"
+ARCHIVE_NAME="${REV_NAME}.tar.xz"
+COMPRESSION_FLAGS="-cJvf"
 
 if [ "${RELEASE_NAME}" = "mainline" ]; then
     DIR_NAME="${REV_NAME}"

.ci/templates/build-msvc.yml

@@ -8,7 +8,7 @@ steps:
   displayName: 'Install vulkan-sdk'
 - script: python -m pip install --upgrade pip conan
   displayName: 'Install conan'
-- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cmake --install . --config Release && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release .. && cd ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

CMakeLists.txt

@@ -13,16 +13,18 @@ project(yuzu)
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
-CMAKE_DEPENDENT_OPTION(YUZU_ALLOW_SYSTEM_SDL2 "Try using system SDL2 before fallling back to one from externals" NOT UNIX "ENABLE_SDL2" OFF)
+option(YUZU_ALLOW_SYSTEM_SDL2 "Try using system SDL2 before fallling back to one from externals" OFF)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
 option(YUZU_USE_BUNDLED_BOOST "Download bundled Boost" OFF)
 
+option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)
+
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ON "WIN32" OFF)
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
@@ -174,7 +176,7 @@ macro(yuzu_find_packages)
         "lz4               1.8         lz4/1.9.2"
         "nlohmann_json     3.8         nlohmann_json/3.8.0"
         "ZLIB              1.2         zlib/1.2.11"
-        "zstd              1.4         zstd/1.4.8"
+        "zstd              1.5         zstd/1.5.0"
     # can't use opus until AVX check is fixed: https://github.com/yuzu-emu/yuzu/pull/4068
         #"opus              1.3         opus/1.3.1"
     )
@@ -240,6 +242,7 @@ yuzu_find_packages()
 
 # Qt5 requires that we find components, so it doesn't fit our pretty little find package function
 if(ENABLE_QT)
+    set(QT_VERSION 5.12)
     # We want to load the generated conan qt config so that we get the QT_ROOT var so that we can use the official
     # Qt5Config inside the root folder instead of the conan generated one.
     if(EXISTS ${CMAKE_BINARY_DIR}/qtConfig.cmake)
@@ -247,22 +250,40 @@ if(ENABLE_QT)
         list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
         list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
     endif()
+
+    # Check for system Qt on Linux, fallback to bundled Qt
+    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+        if (NOT YUZU_USE_BUNDLED_QT)
+            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets QUIET)
+            if (NOT Qt5_FOUND)
+                set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
+            endif()
+        endif()
+        if (YUZU_USE_BUNDLED_QT)
+            # Binary package currently does not support Qt webengine, so make sure it's disabled
+            set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
+        endif()
+    endif()
+
     # Workaround for an issue where conan tries to build Qt from scratch instead of download prebuilt binaries
     set(QT_PREFIX_HINT)
+
     if(YUZU_USE_BUNDLED_QT)
         if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.12.8-msvc2017_64)
+            set(QT_BUILD qt-5.12.8-msvc2017_64)
+        elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
+            set(QT_BUILD qt5_5_15_2)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
         endif()
 
-        if (DEFINED QT_VER)
-            download_bundled_external("qt/" ${QT_VER} QT_PREFIX)
+        if (DEFINED QT_BUILD)
+            download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
         endif()
 
         set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
     endif()
-    find_package(Qt5 5.9 COMPONENTS Widgets ${QT_PREFIX_HINT})
+    find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets ${QT_PREFIX_HINT} NO_CMAKE_SYSTEM_PATH)
     if (YUZU_USE_QT_WEB_ENGINE)
         find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
     endif()
@@ -271,6 +292,7 @@ if(ENABLE_QT)
         find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
     endif()
 endif()
+
 # find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the yuzu_find_package
 if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
@@ -379,7 +401,7 @@ if (CONAN_REQUIRED_LIBS)
     if(ENABLE_QT)
         list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
         list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
-        find_package(Qt5 5.9 REQUIRED COMPONENTS Widgets)
+        find_package(Qt5 5.12 REQUIRED COMPONENTS Widgets)
         if (YUZU_USE_QT_WEB_ENGINE)
             find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
         endif()
@@ -400,14 +422,22 @@ elseif (TARGET Boost::boost)
 endif()
 
 # Ensure libusb is properly configured (based on dolphin libusb include)
-if(NOT APPLE)
+if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
     include(FindPkgConfig)
-    find_package(LibUSB)
-endif()
-if (NOT LIBUSB_FOUND)
-    add_subdirectory(externals/libusb)
-    set(LIBUSB_INCLUDE_DIR "")
-    set(LIBUSB_LIBRARIES usb)
+    if (PKG_CONFIG_FOUND)
+        pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
+    else()
+        find_package(LibUSB)
+    endif()
+
+    if (LIBUSB_FOUND)
+        add_library(usb INTERFACE)
+        target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
+        target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
+    else()
+        message(WARNING "libusb not found, falling back to externals")
+        set(YUZU_USE_BUNDLED_LIBUSB ON)
+    endif()
 endif()
 
 # List of all FFmpeg components required

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -1,52 +1,111 @@
 function(copy_yuzu_Qt5_deps target_dir)
     include(WindowsCopyFiles)
-    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-    set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
+    if (MSVC)
+        set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+        set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
+    else()
+        set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/")
+        set(Qt5_DLL_DIR "${Qt5_DIR}/../../../lib/")
+    endif()
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
+    set(Qt5_PLATFORMTHEMES_DIR "${Qt5_DIR}/../../../plugins/platformthemes/")
+    set(Qt5_PLATFORMINPUTCONTEXTS_DIR "${Qt5_DIR}/../../../plugins/platforminputcontexts/")
+    set(Qt5_XCBGLINTEGRATIONS_DIR "${Qt5_DIR}/../../../plugins/xcbglintegrations/")
     set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
     set(Qt5_RESOURCES_DIR "${Qt5_DIR}/../../../resources/")
     set(PLATFORMS ${DLL_DEST}plugins/platforms/)
     set(STYLES ${DLL_DEST}plugins/styles/)
     set(IMAGEFORMATS ${DLL_DEST}plugins/imageformats/)
-    windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
-        icudt*.dll
-        icuin*.dll
-        icuuc*.dll
-        Qt5Core$<$<CONFIG:Debug>:d>.*
-        Qt5Gui$<$<CONFIG:Debug>:d>.*
-        Qt5Widgets$<$<CONFIG:Debug>:d>.*
-    )
-
-    if (YUZU_USE_QT_WEB_ENGINE)
-        windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST} 
-            Qt5Network$<$<CONFIG:Debug>:d>.*
-            Qt5Positioning$<$<CONFIG:Debug>:d>.*
-            Qt5PrintSupport$<$<CONFIG:Debug>:d>.*
-            Qt5Qml$<$<CONFIG:Debug>:d>.*
-            Qt5Quick$<$<CONFIG:Debug>:d>.*
-            Qt5QuickWidgets$<$<CONFIG:Debug>:d>.*
-            Qt5WebChannel$<$<CONFIG:Debug>:d>.*
-            Qt5WebEngine$<$<CONFIG:Debug>:d>.*
-            Qt5WebEngineCore$<$<CONFIG:Debug>:d>.*
-            Qt5WebEngineWidgets$<$<CONFIG:Debug>:d>.*
-            QtWebEngineProcess$<$<CONFIG:Debug>:d>.*
+    if (MSVC)
+        windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
+            icudt*.dll
+            icuin*.dll
+            icuuc*.dll
+            Qt5Core$<$<CONFIG:Debug>:d>.*
+            Qt5Gui$<$<CONFIG:Debug>:d>.*
+            Qt5Widgets$<$<CONFIG:Debug>:d>.*
         )
 
-        windows_copy_files(${target_dir} ${Qt5_RESOURCES_DIR} ${DLL_DEST}
-            qtwebengine_resources.pak
-            qtwebengine_devtools_resources.pak
-            qtwebengine_resources_100p.pak
-            qtwebengine_resources_200p.pak
-            icudtl.dat
-        )
-    endif ()
-    windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
-    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
-    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
-        qjpeg$<$<CONFIG:Debug>:d>.*
-        qgif$<$<CONFIG:Debug>:d>.*
-        )
+        if (YUZU_USE_QT_WEB_ENGINE)
+            windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
+                Qt5Network$<$<CONFIG:Debug>:d>.*
+                Qt5Positioning$<$<CONFIG:Debug>:d>.*
+                Qt5PrintSupport$<$<CONFIG:Debug>:d>.*
+                Qt5Qml$<$<CONFIG:Debug>:d>.*
+                Qt5Quick$<$<CONFIG:Debug>:d>.*
+                Qt5QuickWidgets$<$<CONFIG:Debug>:d>.*
+                Qt5WebChannel$<$<CONFIG:Debug>:d>.*
+                Qt5WebEngine$<$<CONFIG:Debug>:d>.*
+                Qt5WebEngineCore$<$<CONFIG:Debug>:d>.*
+                Qt5WebEngineWidgets$<$<CONFIG:Debug>:d>.*
+                QtWebEngineProcess$<$<CONFIG:Debug>:d>.*
+            )
+
+            windows_copy_files(${target_dir} ${Qt5_RESOURCES_DIR} ${DLL_DEST}
+                qtwebengine_resources.pak
+                qtwebengine_devtools_resources.pak
+                qtwebengine_resources_100p.pak
+                qtwebengine_resources_200p.pak
+                icudtl.dat
+            )
+        endif ()
+        windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
+        windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
+        windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
+            qjpeg$<$<CONFIG:Debug>:d>.*
+            qgif$<$<CONFIG:Debug>:d>.*
+            )
+    else()
+        set(Qt5_DLLS
+            "${Qt5_DLL_DIR}libQt5Core.so.5"
+            "${Qt5_DLL_DIR}libQt5DBus.so.5"
+            "${Qt5_DLL_DIR}libQt5Gui.so.5"
+            "${Qt5_DLL_DIR}libQt5Widgets.so.5"
+            "${Qt5_DLL_DIR}libQt5XcbQpa.so.5"
+            "${Qt5_DLL_DIR}libicudata.so.60"
+            "${Qt5_DLL_DIR}libicui18n.so.60"
+            "${Qt5_DLL_DIR}libicuuc.so.60"
+            )
+        set(Qt5_IMAGEFORMAT_DLLS
+            "${Qt5_IMAGEFORMATS_DIR}libqjpeg.so"
+            "${Qt5_IMAGEFORMATS_DIR}libqgif.so"
+            "${Qt5_IMAGEFORMATS_DIR}libqico.so"
+            )
+        set(Qt5_PLATFORMTHEME_DLLS
+            "${Qt5_PLATFORMTHEMES_DIR}libqgtk3.so"
+            "${Qt5_PLATFORMTHEMES_DIR}libqxdgdesktopportal.so"
+            )
+        set(Qt5_PLATFORM_DLLS
+            "${Qt5_PLATFORMS_DIR}libqxcb.so"
+            )
+        set(Qt5_PLATFORMINPUTCONTEXT_DLLS
+            "${Qt5_PLATFORMINPUTCONTEXTS_DIR}libcomposeplatforminputcontextplugin.so"
+            "${Qt5_PLATFORMINPUTCONTEXTS_DIR}libibusplatforminputcontextplugin.so"
+            )
+        set(Qt5_XCBGLINTEGRATION_DLLS
+            "${Qt5_XCBGLINTEGRATIONS_DIR}libqxcb-glx-integration.so"
+            )
+        foreach(LIB ${Qt5_DLLS})
+            file(COPY ${LIB} DESTINATION "${DLL_DEST}/lib" FOLLOW_SYMLINK_CHAIN)
+        endforeach()
+        foreach(LIB ${Qt5_IMAGEFORMAT_DLLS})
+            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/imageformats/" FOLLOW_SYMLINK_CHAIN)
+        endforeach()
+        foreach(LIB ${Qt5_PLATFORMTHEME_DLLS})
+            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/platformthemes/" FOLLOW_SYMLINK_CHAIN)
+        endforeach()
+        foreach(LIB ${Qt5_PLATFORM_DLLS})
+            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/platforms/" FOLLOW_SYMLINK_CHAIN)
+        endforeach()
+        foreach(LIB ${Qt5_PLATFORMINPUTCONTEXT_DLLS})
+            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/platforminputcontexts/" FOLLOW_SYMLINK_CHAIN)
+        endforeach()
+        foreach(LIB ${Qt5_XCBGLINTEGRATION_DLLS})
+            file(COPY ${LIB} DESTINATION "${DLL_DEST}plugins/xcbglintegrations/" FOLLOW_SYMLINK_CHAIN)
+        endforeach()
+
+    endif()
     # Create an empty qt.conf file. Qt will detect that this file exists, and use the folder that its in as the root folder.
     # This way it'll look for plugins in the root/plugins/ folder
     add_custom_command(TARGET yuzu POST_BUILD

externals/CMakeLists.txt

@@ -45,21 +45,28 @@ target_include_directories(microprofile INTERFACE ./microprofile)
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 
+# libusb
+if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
+    add_subdirectory(libusb)
+endif()
+
 # SDL2
 if (NOT SDL2_FOUND AND ENABLE_SDL2)
-    # Yuzu itself needs: Events Joystick Haptic Sensor Timers
-    # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
-    set(SDL_UNUSED_SUBSYSTEMS
-        Atomic Audio Render Power Threads
-        File CPUinfo Filesystem Locale)
-    foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
-      string(TOUPPER ${_SUB} _OPT)
-      option(SDL_${_OPT} "" OFF)
-    endforeach()
+    if (NOT WIN32)
+        # Yuzu itself needs: Events Joystick Haptic Sensor Timers
+        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
+        set(SDL_UNUSED_SUBSYSTEMS
+            Atomic Audio Render Power Threads
+            File CPUinfo Filesystem Locale)
+        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
+          string(TOUPPER ${_SUB} _OPT)
+          option(SDL_${_OPT} "" OFF)
+        endforeach()
 
+        option(HIDAPI "" ON)
+    endif()
     set(SDL_STATIC ON)
     set(SDL_SHARED OFF)
-    option(HIDAPI "" ON)
 
     add_subdirectory(SDL EXCLUDE_FROM_ALL)
     add_library(SDL2 ALIAS SDL2-static)

externals/libusb/CMakeLists.txt

@@ -1,155 +1,259 @@
-# Ensure libusb compiles with UTF-8 encoding on MSVC
-if(MSVC)
-    add_compile_options(/utf-8)
-endif()
+if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux"))
+    set(LIBUSB_FOUND ON CACHE BOOL "libusb is present" FORCE)
+    set(LIBUSB_VERSION "1.0.24" CACHE STRING "libusb version string" FORCE)
 
-add_library(usb STATIC EXCLUDE_FROM_ALL
-    libusb/libusb/core.c
-    libusb/libusb/core.c
-    libusb/libusb/descriptor.c
-    libusb/libusb/hotplug.c
-    libusb/libusb/io.c
-    libusb/libusb/strerror.c
-    libusb/libusb/sync.c
-)
-set_target_properties(usb PROPERTIES VERSION 1.0.23)
-if(WIN32)
-    target_include_directories(usb
-        BEFORE
-        PUBLIC
-          libusb/libusb
+    # GNU toolchains for some reason doesn't work with the later half of this CMakeLists after
+    # updating to 1.0.24, so we do it the old-fashioned way for now.
 
-        PRIVATE
-          "${CMAKE_CURRENT_BINARY_DIR}"
-    )
+    set(LIBUSB_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/libusb")
+    set(LIBUSB_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libusb")
 
-    if (NOT MINGW)
-        target_include_directories(usb BEFORE PRIVATE libusb/msvc)
+    # Workarounds for MSYS/MinGW
+    if (MSYS)
+        # CMake on Windows passes `C:/`, but we need `/C/` or `/c/` to use `configure`
+        string(REPLACE ":/" "/" LIBUSB_SRC_DIR "${LIBUSB_SRC_DIR}")
+        set(LIBUSB_SRC_DIR "/${LIBUSB_SRC_DIR}")
+
+        # And now that we are using /C/ for srcdir but everything else is using C:/, we need to
+        # compile everything in the source directory, else `configure` won't think the build
+        # environment is sane.
+        set(LIBUSB_PREFIX "${LIBUSB_SRC_DIR}")
     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
-    # LibUSB one comes first
-    BEFORE
+    set(LIBUSB_CONFIGURE "${LIBUSB_SRC_DIR}/configure")
+    set(LIBUSB_MAKEFILE "${LIBUSB_PREFIX}/Makefile")
 
-    PUBLIC
-      libusb/libusb
+    if (MINGW)
+        set(LIBUSB_LIBRARIES "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll.a" CACHE PATH "libusb library path" FORCE)
+        set(LIBUSB_SHARED_LIBRARY "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.dll")
+        set(LIBUSB_SHARED_LIBRARY_DEST "${CMAKE_BINARY_DIR}/bin/libusb-1.0.dll")
 
-    PRIVATE
-      "${CMAKE_CURRENT_BINARY_DIR}"
-)
-endif()
-
-if(WIN32 OR CYGWIN)
-    target_sources(usb PRIVATE
-      libusb/libusb/os/threads_windows.c
-      libusb/libusb/os/windows_winusb.c
-      libusb/libusb/os/windows_usbdk.c
-      libusb/libusb/os/windows_nt_common.c
-    )
-    set(OS_WINDOWS TRUE)
-elseif(APPLE)
-    target_sources(usb PRIVATE
-        libusb/libusb/os/darwin_usb.c
-    )
-    find_library(COREFOUNDATION_LIBRARY CoreFoundation)
-    find_library(IOKIT_LIBRARY IOKit)
-    find_library(OBJC_LIBRARY objc)
-    target_link_libraries(usb PRIVATE
-        ${COREFOUNDATION_LIBRARY}
-        ${IOKIT_LIBRARY}
-        ${OBJC_LIBRARY}
-    )
-    set(OS_DARWIN TRUE)
-elseif(ANDROID)
-    target_sources(usb PRIVATE
-        libusb/libusb/os/linux_usbfs.c
-        libusb/libusb/os/linux_netlink.c
-    )
-    find_library(LOG_LIBRARY log)
-    target_link_libraries(usb PRIVATE ${LOG_LIBRARY})
-    set(OS_LINUX TRUE)
-elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-    target_sources(usb PRIVATE
-        libusb/libusb/os/linux_usbfs.c
-    )
-    find_package(Libudev)
-    if(LIBUDEV_FOUND)
-        target_sources(usb PRIVATE
-            libusb/libusb/os/linux_udev.c
-        )
-        target_link_libraries(usb PRIVATE "${LIBUDEV_LIBRARIES}")
-        target_include_directories(usb PRIVATE "${LIBUDEV_INCLUDE_DIR}")
-        set(HAVE_LIBUDEV TRUE)
-        set(USE_UDEV TRUE)
+        set(LIBUSB_CONFIGURE_ARGS --host=x86_64-w64-mingw32 --build=x86_64-windows)
     else()
+        set(LIBUSB_LIBRARIES "${LIBUSB_PREFIX}/libusb/.libs/libusb-1.0.a" CACHE PATH "libusb library path" FORCE)
+    endif()
+
+    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(
+        OUTPUT
+            "${LIBUSB_LIBRARIES}"
+        COMMAND
+            make
+        WORKING_DIRECTORY
+            "${LIBUSB_PREFIX}"
+    )
+
+    add_custom_command(
+        OUTPUT
+            "${LIBUSB_MAKEFILE}"
+        COMMAND
+            env
+                CFLAGS="${LIBUSB_CFLAGS}"
+            sh "${LIBUSB_CONFIGURE}"
+                ${LIBUSB_CONFIGURE_ARGS}
+                --srcdir="${LIBUSB_SRC_DIR}"
+        WORKING_DIRECTORY
+            "${LIBUSB_PREFIX}"
+    )
+
+    add_custom_command(
+        OUTPUT
+            "${LIBUSB_CONFIGURE}"
+        COMMAND
+            sh "${LIBUSB_SRC_DIR}/bootstrap.sh"
+        WORKING_DIRECTORY
+            "${LIBUSB_SRC_DIR}"
+    )
+
+    add_custom_command(
+        OUTPUT
+            "${LIBUSB_SHARED_LIBRARY_DEST}"
+        COMMAND
+            cp "${LIBUSB_SHARED_LIBRARY}" "${LIBUSB_SHARED_LIBRARY_DEST}"
+    )
+
+    add_custom_target(usb-bootstrap DEPENDS "${LIBUSB_CONFIGURE}")
+    add_custom_target(usb-configure DEPENDS "${LIBUSB_MAKEFILE}" usb-bootstrap)
+    add_custom_target(usb-build ALL DEPENDS "${LIBUSB_LIBRARIES}" usb-configure)
+    # Workaround since static linking didn't work out -- We need to copy the DLL to the bin directory
+    add_custom_target(usb-copy ALL DEPENDS "${LIBUSB_SHARED_LIBRARY_DEST}" usb-build)
+
+    add_library(usb INTERFACE)
+    add_dependencies(usb usb-copy)
+    target_link_libraries(usb INTERFACE "${LIBUSB_LIBRARIES}")
+    target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
+
+    if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+        Include(FindPkgConfig)
+        pkg_check_modules(LIBUDEV REQUIRED libudev)
+
+        if (LIBUDEV_FOUND)
+            target_include_directories(usb INTERFACE "${LIBUDEV_INCLUDE_DIRS}")
+            target_link_libraries(usb INTERFACE "${LIBUDEV_STATIC_LIBRARIES}")
+        endif()
+    endif()
+else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    # Ensure libusb compiles with UTF-8 encoding on MSVC
+    if(MSVC)
+        add_compile_options(/utf-8)
+    endif()
+
+    add_library(usb STATIC EXCLUDE_FROM_ALL
+        libusb/libusb/core.c
+        libusb/libusb/core.c
+        libusb/libusb/descriptor.c
+        libusb/libusb/hotplug.c
+        libusb/libusb/io.c
+        libusb/libusb/strerror.c
+        libusb/libusb/sync.c
+    )
+    set_target_properties(usb PROPERTIES VERSION 1.0.24)
+    if(WIN32)
+        target_include_directories(usb
+            BEFORE
+            PUBLIC
+              libusb/libusb
+
+            PRIVATE
+              "${CMAKE_CURRENT_BINARY_DIR}"
+        )
+
+        if (NOT MINGW)
+            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
+            # LibUSB one comes first
+            BEFORE
+
+            PUBLIC
+              libusb/libusb
+
+            PRIVATE
+              "${CMAKE_CURRENT_BINARY_DIR}"
+        )
+    endif()
+
+    if(WIN32 OR CYGWIN)
         target_sources(usb PRIVATE
+          libusb/libusb/os/threads_windows.c
+          libusb/libusb/os/windows_winusb.c
+          libusb/libusb/os/windows_usbdk.c
+          libusb/libusb/os/windows_common.c
+        )
+        set(OS_WINDOWS TRUE)
+    elseif(APPLE)
+        target_sources(usb PRIVATE
+            libusb/libusb/os/darwin_usb.c
+        )
+        find_library(COREFOUNDATION_LIBRARY CoreFoundation)
+        find_library(IOKIT_LIBRARY IOKit)
+        find_library(OBJC_LIBRARY objc)
+        target_link_libraries(usb PRIVATE
+            ${COREFOUNDATION_LIBRARY}
+            ${IOKIT_LIBRARY}
+            ${OBJC_LIBRARY}
+        )
+        set(OS_DARWIN TRUE)
+    elseif(ANDROID)
+        target_sources(usb PRIVATE
+            libusb/libusb/os/linux_usbfs.c
             libusb/libusb/os/linux_netlink.c
         )
+        find_library(LOG_LIBRARY log)
+        target_link_libraries(usb PRIVATE ${LOG_LIBRARY})
+        set(OS_LINUX TRUE)
+    elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+        target_sources(usb PRIVATE
+            libusb/libusb/os/linux_usbfs.c
+        )
+        find_package(Libudev)
+        if(LIBUDEV_FOUND)
+            target_sources(usb PRIVATE
+                libusb/libusb/os/linux_udev.c
+            )
+            target_link_libraries(usb PRIVATE "${LIBUDEV_LIBRARIES}")
+            target_include_directories(usb PRIVATE "${LIBUDEV_INCLUDE_DIR}")
+            set(HAVE_LIBUDEV TRUE)
+            set(USE_UDEV TRUE)
+        else()
+            target_sources(usb PRIVATE
+                libusb/libusb/os/linux_netlink.c
+            )
+        endif()
+        set(OS_LINUX TRUE)
+    elseif(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
+        target_sources(usb PRIVATE
+            libusb/libusb/os/netbsd_usb.c
+        )
+        set(OS_NETBSD TRUE)
+    elseif(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
+        target_sources(usb PRIVATE
+            libusb/libusb/os/openbsd_usb.c
+        )
+        set(OS_OPENBSD TRUE)
     endif()
-    set(OS_LINUX TRUE)
-elseif(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
-    target_sources(usb PRIVATE
-        libusb/libusb/os/netbsd_usb.c
-    )
-    set(OS_NETBSD TRUE)
-elseif(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
-    target_sources(usb PRIVATE
-        libusb/libusb/os/openbsd_usb.c
-    )
-    set(OS_OPENBSD TRUE)
-endif()
 
-if(UNIX)
-    target_sources(usb PRIVATE
-        libusb/libusb/os/poll_posix.c
-        libusb/libusb/os/threads_posix.c
-    )
-    find_package(Threads REQUIRED)
-    if(THREADS_HAVE_PTHREAD_ARG)
-      target_compile_options(usb PUBLIC "-pthread")
+    if(UNIX)
+        target_sources(usb PRIVATE
+            libusb/libusb/os/events_posix.c
+            libusb/libusb/os/threads_posix.c
+        )
+        find_package(Threads REQUIRED)
+        if(THREADS_HAVE_PTHREAD_ARG)
+          target_compile_options(usb PUBLIC "-pthread")
+        endif()
+        if(CMAKE_THREAD_LIBS_INIT)
+          target_link_libraries(usb PRIVATE "${CMAKE_THREAD_LIBS_INIT}")
+        endif()
+        set(THREADS_POSIX TRUE)
+    elseif(WIN32)
+        target_sources(usb PRIVATE
+            libusb/libusb/os/events_windows.c
+            libusb/libusb/os/threads_windows.c
+        )
     endif()
-    if(CMAKE_THREAD_LIBS_INIT)
-      target_link_libraries(usb PRIVATE "${CMAKE_THREAD_LIBS_INIT}")
+
+    include(CheckFunctionExists)
+    include(CheckIncludeFiles)
+    include(CheckTypeSize)
+    check_include_files(asm/types.h HAVE_ASM_TYPES_H)
+    check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
+    check_include_files(linux/filter.h HAVE_LINUX_FILTER_H)
+    check_include_files(linux/netlink.h HAVE_LINUX_NETLINK_H)
+    check_include_files(poll.h HAVE_POLL_H)
+    check_include_files(signal.h HAVE_SIGNAL_H)
+    check_include_files(strings.h HAVE_STRINGS_H)
+    check_type_size("struct timespec" STRUCT_TIMESPEC)
+    check_function_exists(syslog HAVE_SYSLOG_FUNC)
+    check_include_files(syslog.h HAVE_SYSLOG_H)
+    check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
+    check_include_files(sys/time.h HAVE_SYS_TIME_H)
+    check_include_files(sys/types.h HAVE_SYS_TYPES_H)
+
+    set(CMAKE_EXTRA_INCLUDE_FILES poll.h)
+    check_type_size("nfds_t" nfds_t)
+    unset(CMAKE_EXTRA_INCLUDE_FILES)
+    if(HAVE_NFDS_T)
+        set(POLL_NFDS_TYPE "nfds_t")
+    else()
+        set(POLL_NFDS_TYPE "unsigned int")
     endif()
-    set(THREADS_POSIX TRUE)
-elseif(WIN32)
-    target_sources(usb PRIVATE
-        libusb/libusb/os/poll_windows.c
-        libusb/libusb/os/threads_windows.c
-    )
-endif()
 
-include(CheckFunctionExists)
-include(CheckIncludeFiles)
-include(CheckTypeSize)
-check_include_files(asm/types.h HAVE_ASM_TYPES_H)
-check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
-check_include_files(linux/filter.h HAVE_LINUX_FILTER_H)
-check_include_files(linux/netlink.h HAVE_LINUX_NETLINK_H)
-check_include_files(poll.h HAVE_POLL_H)
-check_include_files(signal.h HAVE_SIGNAL_H)
-check_include_files(strings.h HAVE_STRINGS_H)
-check_type_size("struct timespec" STRUCT_TIMESPEC)
-check_function_exists(syslog HAVE_SYSLOG_FUNC)
-check_include_files(syslog.h HAVE_SYSLOG_H)
-check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
-check_include_files(sys/time.h HAVE_SYS_TIME_H)
-check_include_files(sys/types.h HAVE_SYS_TYPES_H)
-
-set(CMAKE_EXTRA_INCLUDE_FILES poll.h)
-check_type_size("nfds_t" nfds_t)
-unset(CMAKE_EXTRA_INCLUDE_FILES)
-if(HAVE_NFDS_T)
-    set(POLL_NFDS_TYPE "nfds_t")
-else()
-    set(POLL_NFDS_TYPE "unsigned int")
-endif()
-
-check_include_files(sys/timerfd.h USBI_TIMERFD_AVAILABLE)
+    check_include_files(sys/timerfd.h USBI_TIMERFD_AVAILABLE)
 
 
-configure_file(config.h.in config.h)
+    configure_file(config.h.in config.h)
+endif() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")

src/audio_core/audio_renderer.cpp

@@ -197,7 +197,7 @@ ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_param
 
     ReleaseAndQueueBuffers();
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {

src/audio_core/info_updater.cpp

@@ -407,7 +407,7 @@ ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buf
 
     // TODO(ogniK): Sort when splitter is suppoorted
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 bool InfoUpdater::UpdateSinks(SinkContext& sink_context) {

src/common/CMakeLists.txt

@@ -21,14 +21,14 @@ find_package(Git QUIET)
 
 add_custom_command(OUTPUT scm_rev.cpp
     COMMAND ${CMAKE_COMMAND}
-      -DSRC_DIR="${CMAKE_SOURCE_DIR}"
-      -DBUILD_REPOSITORY="${BUILD_REPOSITORY}"
-      -DTITLE_BAR_FORMAT_IDLE="${TITLE_BAR_FORMAT_IDLE}"
-      -DTITLE_BAR_FORMAT_RUNNING="${TITLE_BAR_FORMAT_RUNNING}"
-      -DBUILD_TAG="${BUILD_TAG}"
-      -DBUILD_ID="${DISPLAY_VERSION}"
-      -DGIT_EXECUTABLE="${GIT_EXECUTABLE}"
-      -P "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
+      -DSRC_DIR=${CMAKE_SOURCE_DIR}
+      -DBUILD_REPOSITORY=${BUILD_REPOSITORY}
+      -DTITLE_BAR_FORMAT_IDLE=${TITLE_BAR_FORMAT_IDLE}
+      -DTITLE_BAR_FORMAT_RUNNING=${TITLE_BAR_FORMAT_RUNNING}
+      -DBUILD_TAG=${BUILD_TAG}
+      -DBUILD_ID=${DISPLAY_VERSION}
+      -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
+      -P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake
     DEPENDS
       # WARNING! It was too much work to try and make a common location for this list,
       # so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
@@ -92,6 +92,7 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
       # technically we should regenerate if the git version changed, but its not worth the effort imo
       "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
+    VERBATIM
 )
 
 add_library(common STATIC
@@ -109,7 +110,6 @@ add_library(common STATIC
     cityhash.cpp
     cityhash.h
     common_funcs.h
-    common_paths.h
     common_sizes.h
     common_types.h
     concepts.h
@@ -118,11 +118,21 @@ add_library(common STATIC
     dynamic_library.h
     fiber.cpp
     fiber.h
-    file_util.cpp
-    file_util.h
+    fs/file.cpp
+    fs/file.h
+    fs/fs.cpp
+    fs/fs.h
+    fs/fs_paths.h
+    fs/fs_types.h
+    fs/fs_util.cpp
+    fs/fs_util.h
+    fs/path_util.cpp
+    fs/path_util.h
     hash.h
     hex_util.cpp
     hex_util.h
+    host_memory.cpp
+    host_memory.h
     intrusive_red_black_tree.h
     logging/backend.cpp
     logging/backend.h
@@ -131,6 +141,7 @@ add_library(common STATIC
     logging/log.h
     logging/text_formatter.cpp
     logging/text_formatter.h
+    logging/types.h
     lz4_compression.cpp
     lz4_compression.h
     math_util.h
@@ -147,6 +158,7 @@ add_library(common STATIC
     param_package.cpp
     param_package.h
     parent_of_member.h
+    point.h
     quaternion.h
     ring_buffer.h
     scm_rev.cpp

src/common/common_funcs.h

@@ -97,17 +97,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
         return static_cast<T>(key) == 0;                                                           \
     }
 
-/// Evaluates a boolean expression, and returns a result unless that expression is true.
-#define R_UNLESS(expr, res)                                                                        \
-    {                                                                                              \
-        if (!(expr)) {                                                                             \
-            if (res.IsError()) {                                                                   \
-                LOG_ERROR(Kernel, "Failed with result: {}", res.raw);                              \
-            }                                                                                      \
-            return res;                                                                            \
-        }                                                                                          \
-    }
-
 #define YUZU_NON_COPYABLE(cls)                                                                     \
     cls(const cls&) = delete;                                                                      \
     cls& operator=(const cls&) = delete
@@ -116,20 +105,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
     cls(cls&&) = delete;                                                                           \
     cls& operator=(cls&&) = delete
 
-#define R_SUCCEEDED(res) (res.IsSuccess())
-
-/// Evaluates an expression that returns a result, and returns the result if it would fail.
-#define R_TRY(res_expr)                                                                            \
-    {                                                                                              \
-        const auto _tmp_r_try_rc = (res_expr);                                                     \
-        if (_tmp_r_try_rc.IsError()) {                                                             \
-            return _tmp_r_try_rc;                                                                  \
-        }                                                                                          \
-    }
-
-/// Evaluates a boolean expression, and succeeds if that expression is true.
-#define R_SUCCEED_IF(expr) R_UNLESS(!(expr), RESULT_SUCCESS)
-
 namespace Common {
 
 [[nodiscard]] constexpr u32 MakeMagic(char a, char b, char c, char d) {

src/common/common_paths.h

@@ -1,52 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-// Directory separators, do we need this?
-#define DIR_SEP "/"
-#define DIR_SEP_CHR '/'
-
-#ifndef MAX_PATH
-#define MAX_PATH 260
-#endif
-
-// The user data dir
-#define ROOT_DIR "."
-#define USERDATA_DIR "user"
-#ifdef USER_DIR
-#define EMU_DATA_DIR USER_DIR
-#else
-#define EMU_DATA_DIR "yuzu"
-#endif
-
-// Dirs in both User and Sys
-#define EUR_DIR "EUR"
-#define USA_DIR "USA"
-#define JAP_DIR "JAP"
-
-// Subdirs in the User dir returned by GetUserPath(UserPath::UserDir)
-#define CONFIG_DIR "config"
-#define CACHE_DIR "cache"
-#define SDMC_DIR "sdmc"
-#define NAND_DIR "nand"
-#define SYSDATA_DIR "sysdata"
-#define KEYS_DIR "keys"
-#define LOAD_DIR "load"
-#define DUMP_DIR "dump"
-#define SCREENSHOTS_DIR "screenshots"
-#define SHADER_DIR "shader"
-#define LOG_DIR "log"
-
-// Filenames
-// Files in the directory returned by GetUserPath(UserPath::ConfigDir)
-#define EMU_CONFIG "emu.ini"
-#define DEBUGGER_CONFIG "debugger.ini"
-#define LOGGER_CONFIG "logger.ini"
-// Files in the directory returned by GetUserPath(UserPath::LogDir)
-#define LOG_FILE "yuzu_log.txt"
-
-// Sys files
-#define SHARED_FONT "shared_font.bin"
-#define AES_KEYS "aes_keys.txt"

src/common/common_sizes.h

@@ -24,6 +24,7 @@ enum : u64 {
     Size_128_MB = 128ULL * Size_1_MB,
     Size_448_MB = 448ULL * Size_1_MB,
     Size_507_MB = 507ULL * Size_1_MB,
+    Size_512_MB = 512ULL * Size_1_MB,
     Size_562_MB = 562ULL * Size_1_MB,
     Size_1554_MB = 1554ULL * Size_1_MB,
     Size_2048_MB = 2048ULL * Size_1_MB,

src/common/file_util.h

@@ -1,298 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <cstdio>
-#include <fstream>
-#include <functional>
-#include <limits>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-#include "common/common_types.h"
-#ifdef _MSC_VER
-#include "common/string_util.h"
-#endif
-
-namespace Common::FS {
-
-// User paths for GetUserPath
-enum class UserPath {
-    CacheDir,
-    ConfigDir,
-    KeysDir,
-    LogDir,
-    NANDDir,
-    RootDir,
-    SDMCDir,
-    LoadDir,
-    DumpDir,
-    ScreenshotsDir,
-    ShaderDir,
-    SysDataDir,
-    UserDir,
-};
-
-// FileSystem tree node/
-struct FSTEntry {
-    bool isDirectory;
-    u64 size;                 // file length or number of entries from children
-    std::string physicalName; // name on disk
-    std::string virtualName;  // name in FST names table
-    std::vector<FSTEntry> children;
-};
-
-// Returns true if file filename exists
-[[nodiscard]] bool Exists(const std::string& filename);
-
-// Returns true if filename is a directory
-[[nodiscard]] bool IsDirectory(const std::string& filename);
-
-// Returns the size of filename (64bit)
-[[nodiscard]] u64 GetSize(const std::string& filename);
-
-// Overloaded GetSize, accepts file descriptor
-[[nodiscard]] u64 GetSize(int fd);
-
-// Overloaded GetSize, accepts FILE*
-[[nodiscard]] u64 GetSize(FILE* f);
-
-// Returns true if successful, or path already exists.
-bool CreateDir(const std::string& filename);
-
-// Creates the full path of fullPath returns true on success
-bool CreateFullPath(const std::string& fullPath);
-
-// Deletes a given filename, return true on success
-// Doesn't supports deleting a directory
-bool Delete(const std::string& filename);
-
-// Deletes a directory filename, returns true on success
-bool DeleteDir(const std::string& filename);
-
-// renames file srcFilename to destFilename, returns true on success
-bool Rename(const std::string& srcFilename, const std::string& destFilename);
-
-// copies file srcFilename to destFilename, returns true on success
-bool Copy(const std::string& srcFilename, const std::string& destFilename);
-
-// creates an empty file filename, returns true on success
-bool CreateEmptyFile(const std::string& filename);
-
-/**
- * @param num_entries_out to be assigned by the callable with the number of iterated directory
- * entries, never null
- * @param directory the path to the enclosing directory
- * @param virtual_name the entry name, without any preceding directory info
- * @return whether handling the entry succeeded
- */
-using DirectoryEntryCallable = std::function<bool(
-    u64* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
-
-/**
- * Scans a directory, calling the callback for each file/directory contained within.
- * If the callback returns failure, scanning halts and this function returns failure as well
- * @param num_entries_out assigned by the function with the number of iterated directory entries,
- * can be null
- * @param directory the directory to scan
- * @param callback The callback which will be called for each entry
- * @return whether scanning the directory succeeded
- */
-bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
-                           DirectoryEntryCallable callback);
-
-/**
- * Scans the directory tree, storing the results.
- * @param directory the parent directory to start scanning from
- * @param parent_entry FSTEntry where the filesystem tree results will be stored.
- * @param recursion Number of children directories to read before giving up.
- * @return the total number of files/directories found
- */
-u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                      unsigned int recursion = 0);
-
-// deletes the given directory and anything under it. Returns true on success.
-bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
-
-// Returns the current directory
-[[nodiscard]] std::optional<std::string> GetCurrentDir();
-
-// Create directory and copy contents (does not overwrite existing files)
-void CopyDir(const std::string& source_path, const std::string& dest_path);
-
-// Set the current directory to given directory
-bool SetCurrentDir(const std::string& directory);
-
-// Returns a pointer to a string with a yuzu data dir in the user's home
-// directory. To be used in "multi-user" mode (that is, installed).
-const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
-
-[[nodiscard]] std::string GetHactoolConfigurationPath();
-
-[[nodiscard]] std::string GetNANDRegistrationDir(bool system = false);
-
-// Returns the path to where the sys file are
-[[nodiscard]] std::string GetSysDirectory();
-
-#ifdef __APPLE__
-[[nodiscard]] std::string GetBundleDirectory();
-#endif
-
-#ifdef _WIN32
-[[nodiscard]] const std::string& GetExeDirectory();
-[[nodiscard]] std::string AppDataRoamingDirectory();
-#endif
-
-std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str);
-
-std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str);
-
-/**
- * Splits the filename into 8.3 format
- * Loosely implemented following https://en.wikipedia.org/wiki/8.3_filename
- * @param filename The normal filename to use
- * @param short_name A 9-char array in which the short name will be written
- * @param extension A 4-char array in which the extension will be written
- */
-void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
-                     std::array<char, 4>& extension);
-
-// Splits the path on '/' or '\' and put the components into a vector
-// i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
-[[nodiscard]] std::vector<std::string> SplitPathComponents(std::string_view filename);
-
-// Gets all of the text up to the last '/' or '\' in the path.
-[[nodiscard]] std::string_view GetParentPath(std::string_view path);
-
-// Gets all of the text after the first '/' or '\' in the path.
-[[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
-
-// Gets the filename of the path
-[[nodiscard]] std::string_view GetFilename(std::string_view path);
-
-// Gets the extension of the filename
-[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
-
-// Removes the final '/' or '\' if one exists
-[[nodiscard]] std::string_view RemoveTrailingSlash(std::string_view path);
-
-// Creates a new vector containing indices [first, last) from the original.
-template <typename T>
-[[nodiscard]] std::vector<T> SliceVector(const std::vector<T>& vector, std::size_t first,
-                                         std::size_t last) {
-    if (first >= last) {
-        return {};
-    }
-    last = std::min<std::size_t>(last, vector.size());
-    return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
-}
-
-enum class DirectorySeparator {
-    ForwardSlash,
-    BackwardSlash,
-    PlatformDefault,
-};
-
-// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
-// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
-[[nodiscard]] std::string SanitizePath(
-    std::string_view path,
-    DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
-
-// To deal with Windows being dumb at Unicode
-template <typename T>
-void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode) {
-#ifdef _MSC_VER
-    fstream.open(Common::UTF8ToUTF16W(filename), openmode);
-#else
-    fstream.open(filename, openmode);
-#endif
-}
-
-// simple wrapper for cstdlib file functions to
-// hopefully will make error checking easier
-// and make forgetting an fclose() harder
-class IOFile : public NonCopyable {
-public:
-    IOFile();
-    // flags is used for windows specific file open mode flags, which
-    // allows yuzu to open the logs in shared write mode, so that the file
-    // isn't considered "locked" while yuzu is open and people can open the log file and view it
-    IOFile(const std::string& filename, const char openmode[], int flags = 0);
-
-    ~IOFile();
-
-    IOFile(IOFile&& other) noexcept;
-    IOFile& operator=(IOFile&& other) noexcept;
-
-    void Swap(IOFile& other) noexcept;
-
-    bool Open(const std::string& filename, const char openmode[], int flags = 0);
-    bool Close();
-
-    template <typename T>
-    std::size_t ReadArray(T* data, std::size_t length) const {
-        static_assert(std::is_trivially_copyable_v<T>,
-                      "Given array does not consist of trivially copyable objects");
-
-        return ReadImpl(data, length, sizeof(T));
-    }
-
-    template <typename T>
-    std::size_t WriteArray(const T* data, std::size_t length) {
-        static_assert(std::is_trivially_copyable_v<T>,
-                      "Given array does not consist of trivially copyable objects");
-
-        return WriteImpl(data, length, sizeof(T));
-    }
-
-    template <typename T>
-    std::size_t ReadBytes(T* data, std::size_t length) const {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
-        return ReadArray(reinterpret_cast<char*>(data), length);
-    }
-
-    template <typename T>
-    std::size_t WriteBytes(const T* data, std::size_t length) {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
-        return WriteArray(reinterpret_cast<const char*>(data), length);
-    }
-
-    template <typename T>
-    std::size_t WriteObject(const T& object) {
-        static_assert(!std::is_pointer_v<T>, "WriteObject arguments must not be a pointer");
-        return WriteArray(&object, 1);
-    }
-
-    std::size_t WriteString(std::string_view str) {
-        return WriteArray(str.data(), str.length());
-    }
-
-    [[nodiscard]] bool IsOpen() const {
-        return nullptr != m_file;
-    }
-
-    bool Seek(s64 off, int origin) const;
-    [[nodiscard]] u64 Tell() const;
-    [[nodiscard]] u64 GetSize() const;
-    bool Resize(u64 size);
-    bool Flush();
-
-    // clear error state
-    void Clear() {
-        std::clearerr(m_file);
-    }
-
-private:
-    std::size_t ReadImpl(void* data, std::size_t length, std::size_t data_size) const;
-    std::size_t WriteImpl(const void* data, std::size_t length, std::size_t data_size);
-
-    std::FILE* m_file = nullptr;
-};
-
-} // namespace Common::FS

src/common/fs/file.cpp

@@ -0,0 +1,392 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+
+#ifdef _WIN32
+#include <io.h>
+#include <share.h>
+#else
+#include <unistd.h>
+#endif
+
+#ifdef _MSC_VER
+#define fileno _fileno
+#define fseeko _fseeki64
+#define ftello _ftelli64
+#endif
+
+namespace Common::FS {
+
+namespace fs = std::filesystem;
+
+namespace {
+
+#ifdef _WIN32
+
+/**
+ * Converts the file access mode and file type enums to a file access mode wide string.
+ *
+ * @param mode File access mode
+ * @param type File type
+ *
+ * @returns A pointer to a wide string representing the file access mode.
+ */
+[[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileType type) {
+    switch (type) {
+    case FileType::BinaryFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return L"rb";
+        case FileAccessMode::Write:
+            return L"wb";
+        case FileAccessMode::Append:
+            return L"ab";
+        case FileAccessMode::ReadWrite:
+            return L"r+b";
+        case FileAccessMode::ReadAppend:
+            return L"a+b";
+        }
+        break;
+    case FileType::TextFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return L"r";
+        case FileAccessMode::Write:
+            return L"w";
+        case FileAccessMode::Append:
+            return L"a";
+        case FileAccessMode::ReadWrite:
+            return L"r+";
+        case FileAccessMode::ReadAppend:
+            return L"a+";
+        }
+        break;
+    }
+
+    return L"";
+}
+
+/**
+ * Converts the file-share access flag enum to a Windows defined file-share access flag.
+ *
+ * @param flag File-share access flag
+ *
+ * @returns Windows defined file-share access flag.
+ */
+[[nodiscard]] constexpr int ToWindowsFileShareFlag(FileShareFlag flag) {
+    switch (flag) {
+    case FileShareFlag::ShareNone:
+    default:
+        return _SH_DENYRW;
+    case FileShareFlag::ShareReadOnly:
+        return _SH_DENYWR;
+    case FileShareFlag::ShareWriteOnly:
+        return _SH_DENYRD;
+    case FileShareFlag::ShareReadWrite:
+        return _SH_DENYNO;
+    }
+}
+
+#else
+
+/**
+ * Converts the file access mode and file type enums to a file access mode string.
+ *
+ * @param mode File access mode
+ * @param type File type
+ *
+ * @returns A pointer to a string representing the file access mode.
+ */
+[[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileType type) {
+    switch (type) {
+    case FileType::BinaryFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return "rb";
+        case FileAccessMode::Write:
+            return "wb";
+        case FileAccessMode::Append:
+            return "ab";
+        case FileAccessMode::ReadWrite:
+            return "r+b";
+        case FileAccessMode::ReadAppend:
+            return "a+b";
+        }
+        break;
+    case FileType::TextFile:
+        switch (mode) {
+        case FileAccessMode::Read:
+            return "r";
+        case FileAccessMode::Write:
+            return "w";
+        case FileAccessMode::Append:
+            return "a";
+        case FileAccessMode::ReadWrite:
+            return "r+";
+        case FileAccessMode::ReadAppend:
+            return "a+";
+        }
+        break;
+    }
+
+    return "";
+}
+
+#endif
+
+/**
+ * Converts the seek origin enum to a seek origin integer.
+ *
+ * @param origin Seek origin
+ *
+ * @returns Seek origin integer.
+ */
+[[nodiscard]] constexpr int ToSeekOrigin(SeekOrigin origin) {
+    switch (origin) {
+    case SeekOrigin::SetOrigin:
+    default:
+        return SEEK_SET;
+    case SeekOrigin::CurrentPosition:
+        return SEEK_CUR;
+    case SeekOrigin::End:
+        return SEEK_END;
+    }
+}
+
+} // Anonymous namespace
+
+std::string ReadStringFromFile(const std::filesystem::path& path, FileType type) {
+    if (!IsFile(path)) {
+        return "";
+    }
+
+    IOFile io_file{path, FileAccessMode::Read, type};
+
+    return io_file.ReadString(io_file.GetSize());
+}
+
+size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
+                         std::string_view string) {
+    if (!IsFile(path)) {
+        return 0;
+    }
+
+    IOFile io_file{path, FileAccessMode::Write, type};
+
+    return io_file.WriteString(string);
+}
+
+size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
+                          std::string_view string) {
+    if (!IsFile(path)) {
+        return 0;
+    }
+
+    IOFile io_file{path, FileAccessMode::Append, type};
+
+    return io_file.WriteString(string);
+}
+
+IOFile::IOFile() = default;
+
+IOFile::IOFile(const std::string& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Open(path, mode, type, flag);
+}
+
+IOFile::IOFile(std::string_view path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Open(path, mode, type, flag);
+}
+
+IOFile::IOFile(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Open(path, mode, type, flag);
+}
+
+IOFile::~IOFile() {
+    Close();
+}
+
+IOFile::IOFile(IOFile&& other) noexcept {
+    std::swap(file_path, other.file_path);
+    std::swap(file_access_mode, other.file_access_mode);
+    std::swap(file_type, other.file_type);
+    std::swap(file, other.file);
+}
+
+IOFile& IOFile::operator=(IOFile&& other) noexcept {
+    std::swap(file_path, other.file_path);
+    std::swap(file_access_mode, other.file_access_mode);
+    std::swap(file_type, other.file_type);
+    std::swap(file, other.file);
+    return *this;
+}
+
+fs::path IOFile::GetPath() const {
+    return file_path;
+}
+
+FileAccessMode IOFile::GetAccessMode() const {
+    return file_access_mode;
+}
+
+FileType IOFile::GetType() const {
+    return file_type;
+}
+
+void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
+    Close();
+
+    file_path = path;
+    file_access_mode = mode;
+    file_type = type;
+
+    errno = 0;
+
+#ifdef _WIN32
+    if (flag != FileShareFlag::ShareNone) {
+        file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
+    } else {
+        _wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
+    }
+#else
+    file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
+#endif
+
+    if (!IsOpen()) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
+}
+
+void IOFile::Close() {
+    if (!IsOpen()) {
+        return;
+    }
+
+    errno = 0;
+
+    const auto close_result = std::fclose(file) == 0;
+
+    if (!close_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
+
+    file = nullptr;
+}
+
+bool IOFile::IsOpen() const {
+    return file != nullptr;
+}
+
+std::string IOFile::ReadString(size_t length) const {
+    std::vector<char> string_buffer(length);
+
+    const auto chars_read = ReadSpan<char>(string_buffer);
+    const auto string_size = chars_read != length ? chars_read : length;
+
+    return std::string{string_buffer.data(), string_size};
+}
+
+size_t IOFile::WriteString(std::span<const char> string) const {
+    return WriteSpan(string);
+}
+
+bool IOFile::Flush() const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+#ifdef _WIN32
+    const auto flush_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
+#else
+    const auto flush_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
+#endif
+
+    if (!flush_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+    }
+
+    return flush_result;
+}
+
+bool IOFile::SetSize(u64 size) const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+#ifdef _WIN32
+    const auto set_size_result = _chsize_s(fileno(file), static_cast<s64>(size)) == 0;
+#else
+    const auto set_size_result = ftruncate(fileno(file), static_cast<s64>(size)) == 0;
+#endif
+
+    if (!set_size_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
+                  PathToUTF8String(file_path), size, ec.message());
+    }
+
+    return set_size_result;
+}
+
+u64 IOFile::GetSize() const {
+    if (!IsOpen()) {
+        return 0;
+    }
+
+    std::error_code ec;
+
+    const auto file_size = fs::file_size(file_path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
+                  PathToUTF8String(file_path), ec.message());
+        return 0;
+    }
+
+    return file_size;
+}
+
+bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
+    if (!IsOpen()) {
+        return false;
+    }
+
+    errno = 0;
+
+    const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
+
+    if (!seek_result) {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
+                  PathToUTF8String(file_path), offset, origin, ec.message());
+    }
+
+    return seek_result;
+}
+
+s64 IOFile::Tell() const {
+    if (!IsOpen()) {
+        return 0;
+    }
+
+    errno = 0;
+
+    return ftello(file);
+}
+
+} // namespace Common::FS

src/common/fs/file.h

@@ -0,0 +1,452 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <span>
+#include <type_traits>
+#include <vector>
+
+#include "common/concepts.h"
+#include "common/fs/fs_types.h"
+#include "common/fs/fs_util.h"
+
+namespace Common::FS {
+
+enum class SeekOrigin {
+    SetOrigin,       // Seeks from the start of the file.
+    CurrentPosition, // Seeks from the current file pointer position.
+    End,             // Seeks from the end of the file.
+};
+
+/**
+ * Opens a file stream at path with the specified open mode.
+ *
+ * @param file_stream Reference to file stream
+ * @param path Filesystem path
+ * @param open_mode File stream open mode
+ */
+template <typename FileStream>
+void OpenFileStream(FileStream& file_stream, const std::filesystem::path& path,
+                    std::ios_base::openmode open_mode) {
+    file_stream.open(path, open_mode);
+}
+
+#ifdef _WIN32
+template <typename FileStream, typename Path>
+void OpenFileStream(FileStream& file_stream, const Path& path, std::ios_base::openmode open_mode) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        file_stream.open(ToU8String(path), open_mode);
+    } else {
+        file_stream.open(std::filesystem::path{path}, open_mode);
+    }
+}
+#endif
+
+/**
+ * Reads an entire file at path and returns a string of the contents read from the file.
+ * If the filesystem object at path is not a file, this function returns an empty string.
+ *
+ * @param path Filesystem path
+ * @param type File type
+ *
+ * @returns A string of the contents read from the file.
+ */
+[[nodiscard]] std::string ReadStringFromFile(const std::filesystem::path& path, FileType type);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] std::string ReadStringFromFile(const Path& path, FileType type) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return ReadStringFromFile(ToU8String(path), type);
+    } else {
+        return ReadStringFromFile(std::filesystem::path{path}, type);
+    }
+}
+#endif
+
+/**
+ * Writes a string to a file at path and returns the number of characters successfully written.
+ * If a file already exists at path, its contents will be erased.
+ * If the filesystem object at path is not a file, this function returns 0.
+ *
+ * @param path Filesystem path
+ * @param type File type
+ *
+ * @returns Number of characters successfully written.
+ */
+[[nodiscard]] size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
+                                       std::string_view string);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] size_t WriteStringToFile(const Path& path, FileType type, std::string_view string) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return WriteStringToFile(ToU8String(path), type, string);
+    } else {
+        return WriteStringToFile(std::filesystem::path{path}, type, string);
+    }
+}
+#endif
+
+/**
+ * Appends a string to a file at path and returns the number of characters successfully written.
+ * If the filesystem object at path is not a file, this function returns 0.
+ *
+ * @param path Filesystem path
+ * @param type File type
+ *
+ * @returns Number of characters successfully written.
+ */
+[[nodiscard]] size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
+                                        std::string_view string);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] size_t AppendStringToFile(const Path& path, FileType type, std::string_view string) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return AppendStringToFile(ToU8String(path), type, string);
+    } else {
+        return AppendStringToFile(std::filesystem::path{path}, type, string);
+    }
+}
+#endif
+
+class IOFile final {
+public:
+    IOFile();
+
+    explicit IOFile(const std::string& path, FileAccessMode mode,
+                    FileType type = FileType::BinaryFile,
+                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
+
+    explicit IOFile(std::string_view path, FileAccessMode mode,
+                    FileType type = FileType::BinaryFile,
+                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
+
+    /**
+     * An IOFile is a lightweight wrapper on C Library file operations.
+     * Automatically closes an open file on the destruction of an IOFile object.
+     *
+     * @param path Filesystem path
+     * @param mode File access mode
+     * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
+     * @param flag (Windows only) File-share access flag, default is ShareReadOnly
+     */
+    explicit IOFile(const std::filesystem::path& path, FileAccessMode mode,
+                    FileType type = FileType::BinaryFile,
+                    FileShareFlag flag = FileShareFlag::ShareReadOnly);
+
+    ~IOFile();
+
+    IOFile(const IOFile&) = delete;
+    IOFile& operator=(const IOFile&) = delete;
+
+    IOFile(IOFile&& other) noexcept;
+    IOFile& operator=(IOFile&& other) noexcept;
+
+    /**
+     * Gets the path of the file.
+     *
+     * @returns The path of the file.
+     */
+    [[nodiscard]] std::filesystem::path GetPath() const;
+
+    /**
+     * Gets the access mode of the file.
+     *
+     * @returns The access mode of the file.
+     */
+    [[nodiscard]] FileAccessMode GetAccessMode() const;
+
+    /**
+     * Gets the type of the file.
+     *
+     * @returns The type of the file.
+     */
+    [[nodiscard]] FileType GetType() const;
+
+    /**
+     * Opens a file at path with the specified file access mode.
+     * This function behaves differently depending on the FileAccessMode.
+     * These behaviors are documented in each enum value of FileAccessMode.
+     *
+     * @param path Filesystem path
+     * @param mode File access mode
+     * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
+     * @param flag (Windows only) File-share access flag, default is ShareReadOnly
+     */
+    void Open(const std::filesystem::path& path, FileAccessMode mode,
+              FileType type = FileType::BinaryFile,
+              FileShareFlag flag = FileShareFlag::ShareReadOnly);
+
+#ifdef _WIN32
+    template <typename Path>
+    [[nodiscard]] void Open(const Path& path, FileAccessMode mode,
+                            FileType type = FileType::BinaryFile,
+                            FileShareFlag flag = FileShareFlag::ShareReadOnly) {
+        using ValueType = typename Path::value_type;
+        if constexpr (IsChar<ValueType>) {
+            Open(ToU8String(path), mode, type, flag);
+        } else {
+            Open(std::filesystem::path{path}, mode, type, flag);
+        }
+    }
+#endif
+
+    /// Closes the file if it is opened.
+    void Close();
+
+    /**
+     * Checks whether the file is open.
+     * Use this to check whether the calls to Open() or Close() succeeded.
+     *
+     * @returns True if the file is open, false otherwise.
+     */
+    [[nodiscard]] bool IsOpen() const;
+
+    /**
+     * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
+     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
+     * ReadObject and T must be a trivially copyable object.
+     *
+     * See ReadSpan for more details if T is a contiguous container.
+     * See ReadObject for more details if T is a trivially copyable object.
+     *
+     * @tparam T Contiguous container or trivially copyable object
+     *
+     * @param data Container of T::value_type data or reference to object
+     *
+     * @returns Count of T::value_type data or objects successfully read.
+     */
+    template <typename T>
+    [[nodiscard]] size_t Read(T& data) const {
+        if constexpr (IsSTLContainer<T>) {
+            using ContiguousType = typename T::value_type;
+            static_assert(std::is_trivially_copyable_v<ContiguousType>,
+                          "Data type must be trivially copyable.");
+            return ReadSpan<ContiguousType>(data);
+        } else {
+            return ReadObject(data) ? 1 : 0;
+        }
+    }
+
+    /**
+     * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
+     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
+     * WriteObject and T must be a trivially copyable object.
+     *
+     * See WriteSpan for more details if T is a contiguous container.
+     * See WriteObject for more details if T is a trivially copyable object.
+     *
+     * @tparam T Contiguous container or trivially copyable object
+     *
+     * @param data Container of T::value_type data or const reference to object
+     *
+     * @returns Count of T::value_type data or objects successfully written.
+     */
+    template <typename T>
+    [[nodiscard]] size_t Write(const T& data) const {
+        if constexpr (IsSTLContainer<T>) {
+            using ContiguousType = typename T::value_type;
+            static_assert(std::is_trivially_copyable_v<ContiguousType>,
+                          "Data type must be trivially copyable.");
+            return WriteSpan<ContiguousType>(data);
+        } else {
+            static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+            return WriteObject(data) ? 1 : 0;
+        }
+    }
+
+    /**
+     * Reads a span of T data from a file sequentially.
+     * This function reads from the current position of the file pointer and
+     * advances it by the (count of T * sizeof(T)) bytes successfully read.
+     *
+     * Failures occur when:
+     * - The file is not open
+     * - The opened file lacks read permissions
+     * - Attempting to read beyond the end-of-file
+     *
+     * @tparam T Data type
+     *
+     * @param data Span of T data
+     *
+     * @returns Count of T data successfully read.
+     */
+    template <typename T>
+    [[nodiscard]] size_t ReadSpan(std::span<T> data) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+
+        if (!IsOpen()) {
+            return 0;
+        }
+
+        return std::fread(data.data(), sizeof(T), data.size(), file);
+    }
+
+    /**
+     * Writes a span of T data to a file sequentially.
+     * This function writes from the current position of the file pointer and
+     * advances it by the (count of T * sizeof(T)) bytes successfully written.
+     *
+     * Failures occur when:
+     * - The file is not open
+     * - The opened file lacks write permissions
+     *
+     * @tparam T Data type
+     *
+     * @param data Span of T data
+     *
+     * @returns Count of T data successfully written.
+     */
+    template <typename T>
+    [[nodiscard]] size_t WriteSpan(std::span<const T> data) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+
+        if (!IsOpen()) {
+            return 0;
+        }
+
+        return std::fwrite(data.data(), sizeof(T), data.size(), file);
+    }
+
+    /**
+     * Reads a T object from a file sequentially.
+     * This function reads from the current position of the file pointer and
+     * advances it by the sizeof(T) bytes successfully read.
+     *
+     * Failures occur when:
+     * - The file is not open
+     * - The opened file lacks read permissions
+     * - Attempting to read beyond the end-of-file
+     *
+     * @tparam T Data type
+     *
+     * @param object Reference to object
+     *
+     * @returns True if the object is successfully read from the file, false otherwise.
+     */
+    template <typename T>
+    [[nodiscard]] bool ReadObject(T& object) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
+
+        if (!IsOpen()) {
+            return false;
+        }
+
+        return std::fread(&object, sizeof(T), 1, file) == 1;
+    }
+
+    /**
+     * Writes a T object to a file sequentially.
+     * This function writes from the current position of the file pointer and
+     * advances it by the sizeof(T) bytes successfully written.
+     *
+     * Failures occur when:
+     * - The file is not open
+     * - The opened file lacks write permissions
+     *
+     * @tparam T Data type
+     *
+     * @param object Const reference to object
+     *
+     * @returns True if the object is successfully written to the file, false otherwise.
+     */
+    template <typename T>
+    [[nodiscard]] bool WriteObject(const T& object) const {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
+
+        if (!IsOpen()) {
+            return false;
+        }
+
+        return std::fwrite(&object, sizeof(T), 1, file) == 1;
+    }
+
+    /**
+     * Specialized function to read a string of a given length from a file sequentially.
+     * This function writes from the current position of the file pointer and
+     * advances it by the number of characters successfully read.
+     * The size of the returned string may not match length if not all bytes are successfully read.
+     *
+     * @param length Length of the string
+     *
+     * @returns A string read from the file.
+     */
+    [[nodiscard]] std::string ReadString(size_t length) const;
+
+    /**
+     * Specialized function to write a string to a file sequentially.
+     * This function writes from the current position of the file pointer and
+     * advances it by the number of characters successfully written.
+     *
+     * @param string Span of const char backed std::string or std::string_view
+     *
+     * @returns Number of characters successfully written.
+     */
+    [[nodiscard]] size_t WriteString(std::span<const char> string) const;
+
+    /**
+     * Flushes any unwritten buffered data into the file.
+     *
+     * @returns True if the flush was successful, false otherwise.
+     */
+    [[nodiscard]] bool Flush() const;
+
+    /**
+     * Resizes the file to a given size.
+     * If the file is resized to a smaller size, the remainder of the file is discarded.
+     * If the file is resized to a larger size, the new area appears as if zero-filled.
+     *
+     * Failures occur when:
+     * - The file is not open
+     *
+     * @param size File size in bytes
+     *
+     * @returns True if the file resize succeeded, false otherwise.
+     */
+    [[nodiscard]] bool SetSize(u64 size) const;
+
+    /**
+     * Gets the size of the file.
+     *
+     * Failures occur when:
+     * - The file is not open
+     *
+     * @returns The file size in bytes of the file. Returns 0 on failure.
+     */
+    [[nodiscard]] u64 GetSize() const;
+
+    /**
+     * Moves the current position of the file pointer with the specified offset and seek origin.
+     *
+     * @param offset Offset from seek origin
+     * @param origin Seek origin
+     *
+     * @returns True if the file pointer has moved to the specified offset, false otherwise.
+     */
+    [[nodiscard]] bool Seek(s64 offset, SeekOrigin origin = SeekOrigin::SetOrigin) const;
+
+    /**
+     * Gets the current position of the file pointer.
+     *
+     * @returns The current position of the file pointer.
+     */
+    [[nodiscard]] s64 Tell() const;
+
+private:
+    std::filesystem::path file_path;
+    FileAccessMode file_access_mode{};
+    FileType file_type{};
+
+    std::FILE* file = nullptr;
+};
+
+} // namespace Common::FS

src/common/fs/fs.cpp

@@ -0,0 +1,624 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+
+namespace Common::FS {
+
+namespace fs = std::filesystem;
+
+// File Operations
+
+bool NewFile(const fs::path& path, u64 size) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (!Exists(path.parent_path())) {
+        LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
+                  PathToUTF8String(path));
+        return false;
+    }
+
+    if (Exists(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} exists", PathToUTF8String(path));
+        return false;
+    }
+
+    IOFile io_file{path, FileAccessMode::Write};
+
+    if (!io_file.IsOpen()) {
+        LOG_ERROR(Common_Filesystem, "Failed to create a file at path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (!io_file.SetSize(size)) {
+        LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={} to size={}",
+                  PathToUTF8String(path), size);
+        return false;
+    }
+
+    io_file.Close();
+
+    LOG_DEBUG(Common_Filesystem, "Successfully created a file at path={} with size={}",
+              PathToUTF8String(path), size);
+
+    return true;
+}
+
+bool RemoveFile(const fs::path& path) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (!Exists(path)) {
+        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
+                  PathToUTF8String(path));
+        return true;
+    }
+
+    if (!IsFile(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a file",
+                  PathToUTF8String(path));
+        return false;
+    }
+
+    std::error_code ec;
+
+    fs::remove(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to remove the file at path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully removed the file at path={}",
+              PathToUTF8String(path));
+
+    return true;
+}
+
+bool RenameFile(const fs::path& old_path, const fs::path& new_path) {
+    if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
+        LOG_ERROR(Common_Filesystem,
+                  "One or both input path(s) is not valid, old_path={}, new_path={}",
+                  PathToUTF8String(old_path), PathToUTF8String(new_path));
+        return false;
+    }
+
+    if (!Exists(old_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
+                  PathToUTF8String(old_path));
+        return false;
+    }
+
+    if (!IsFile(old_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a file",
+                  PathToUTF8String(old_path));
+        return false;
+    }
+
+    if (Exists(new_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
+                  PathToUTF8String(new_path));
+        return false;
+    }
+
+    std::error_code ec;
+
+    fs::rename(old_path, new_path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to rename the file from old_path={} to new_path={}, ec_message={}",
+                  PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
+              PathToUTF8String(old_path), PathToUTF8String(new_path));
+
+    return true;
+}
+
+std::shared_ptr<IOFile> FileOpen(const fs::path& path, FileAccessMode mode, FileType type,
+                                 FileShareFlag flag) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return nullptr;
+    }
+
+    if (!IsFile(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a file",
+                  PathToUTF8String(path));
+        return nullptr;
+    }
+
+    auto io_file = std::make_shared<IOFile>(path, mode, type, flag);
+
+    if (!io_file->IsOpen()) {
+        io_file.reset();
+
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to open the file at path={} with mode={}, type={}, flag={}",
+                  PathToUTF8String(path), mode, type, flag);
+
+        return nullptr;
+    }
+
+    LOG_DEBUG(Common_Filesystem,
+              "Successfully opened the file at path={} with mode={}, type={}, flag={}",
+              PathToUTF8String(path), mode, type, flag);
+
+    return io_file;
+}
+
+// Directory Operations
+
+bool CreateDir(const fs::path& path) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (!Exists(path.parent_path())) {
+        LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
+                  PathToUTF8String(path));
+        return false;
+    }
+
+    if (IsDir(path)) {
+        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
+                  PathToUTF8String(path));
+        return true;
+    }
+
+    std::error_code ec;
+
+    fs::create_directory(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to create the directory at path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully created the directory at path={}",
+              PathToUTF8String(path));
+
+    return true;
+}
+
+bool CreateDirs(const fs::path& path) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (IsDir(path)) {
+        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
+                  PathToUTF8String(path));
+        return true;
+    }
+
+    std::error_code ec;
+
+    fs::create_directories(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to create the directories at path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully created the directories at path={}",
+              PathToUTF8String(path));
+
+    return true;
+}
+
+bool CreateParentDir(const fs::path& path) {
+    return CreateDir(path.parent_path());
+}
+
+bool CreateParentDirs(const fs::path& path) {
+    return CreateDirs(path.parent_path());
+}
+
+bool RemoveDir(const fs::path& path) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (!Exists(path)) {
+        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
+                  PathToUTF8String(path));
+        return true;
+    }
+
+    if (!IsDir(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
+                  PathToUTF8String(path));
+        return false;
+    }
+
+    std::error_code ec;
+
+    fs::remove(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to remove the directory at path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully removed the directory at path={}",
+              PathToUTF8String(path));
+
+    return true;
+}
+
+bool RemoveDirRecursively(const fs::path& path) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (!Exists(path)) {
+        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
+                  PathToUTF8String(path));
+        return true;
+    }
+
+    if (!IsDir(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
+                  PathToUTF8String(path));
+        return false;
+    }
+
+    std::error_code ec;
+
+    fs::remove_all(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to remove the directory and its contents at path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully removed the directory and its contents at path={}",
+              PathToUTF8String(path));
+
+    return true;
+}
+
+bool RemoveDirContentsRecursively(const fs::path& path) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+    if (!Exists(path)) {
+        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
+                  PathToUTF8String(path));
+        return true;
+    }
+
+    if (!IsDir(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
+                  PathToUTF8String(path));
+        return false;
+    }
+
+    std::error_code ec;
+
+    // TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
+    for (const auto& entry : fs::directory_iterator(path, ec)) {
+        if (ec) {
+            LOG_ERROR(Common_Filesystem,
+                      "Failed to completely enumerate the directory at path={}, ec_message={}",
+                      PathToUTF8String(path), ec.message());
+            break;
+        }
+
+        fs::remove(entry.path(), ec);
+
+        if (ec) {
+            LOG_ERROR(Common_Filesystem,
+                      "Failed to remove the filesystem object at path={}, ec_message={}",
+                      PathToUTF8String(entry.path()), ec.message());
+            break;
+        }
+
+        // TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
+        // recursive_directory_iterator throws an exception despite passing in a std::error_code.
+        if (entry.status().type() == fs::file_type::directory) {
+            return RemoveDirContentsRecursively(entry.path());
+        }
+    }
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to remove all the contents of the directory at path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem,
+              "Successfully removed all the contents of the directory at path={}",
+              PathToUTF8String(path));
+
+    return true;
+}
+
+bool RenameDir(const fs::path& old_path, const fs::path& new_path) {
+    if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
+        LOG_ERROR(Common_Filesystem,
+                  "One or both input path(s) is not valid, old_path={}, new_path={}",
+                  PathToUTF8String(old_path), PathToUTF8String(new_path));
+        return false;
+    }
+
+    if (!Exists(old_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
+                  PathToUTF8String(old_path));
+        return false;
+    }
+
+    if (!IsDir(old_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a directory",
+                  PathToUTF8String(old_path));
+        return false;
+    }
+
+    if (Exists(new_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
+                  PathToUTF8String(new_path));
+        return false;
+    }
+
+    std::error_code ec;
+
+    fs::rename(old_path, new_path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to rename the file from old_path={} to new_path={}, ec_message={}",
+                  PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
+        return false;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
+              PathToUTF8String(old_path), PathToUTF8String(new_path));
+
+    return true;
+}
+
+void IterateDirEntries(const std::filesystem::path& path, const DirEntryCallable& callback,
+                       DirEntryFilter filter) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return;
+    }
+
+    if (!Exists(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
+                  PathToUTF8String(path));
+        return;
+    }
+
+    if (!IsDir(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
+                  PathToUTF8String(path));
+        return;
+    }
+
+    bool callback_error = false;
+
+    std::error_code ec;
+
+    for (const auto& entry : fs::directory_iterator(path, ec)) {
+        if (ec) {
+            break;
+        }
+
+        if (True(filter & DirEntryFilter::File) &&
+            entry.status().type() == fs::file_type::regular) {
+            if (!callback(entry.path())) {
+                callback_error = true;
+                break;
+            }
+        }
+
+        if (True(filter & DirEntryFilter::Directory) &&
+            entry.status().type() == fs::file_type::directory) {
+            if (!callback(entry.path())) {
+                callback_error = true;
+                break;
+            }
+        }
+    }
+
+    if (callback_error || ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to visit all the directory entries of path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
+              PathToUTF8String(path));
+}
+
+void IterateDirEntriesRecursively(const std::filesystem::path& path,
+                                  const DirEntryCallable& callback, DirEntryFilter filter) {
+    if (!ValidatePath(path)) {
+        LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
+        return;
+    }
+
+    if (!Exists(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
+                  PathToUTF8String(path));
+        return;
+    }
+
+    if (!IsDir(path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
+                  PathToUTF8String(path));
+        return;
+    }
+
+    bool callback_error = false;
+
+    std::error_code ec;
+
+    // TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
+    for (const auto& entry : fs::directory_iterator(path, ec)) {
+        if (ec) {
+            break;
+        }
+
+        if (True(filter & DirEntryFilter::File) &&
+            entry.status().type() == fs::file_type::regular) {
+            if (!callback(entry.path())) {
+                callback_error = true;
+                break;
+            }
+        }
+
+        if (True(filter & DirEntryFilter::Directory) &&
+            entry.status().type() == fs::file_type::directory) {
+            if (!callback(entry.path())) {
+                callback_error = true;
+                break;
+            }
+        }
+
+        // TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
+        // recursive_directory_iterator throws an exception despite passing in a std::error_code.
+        if (entry.status().type() == fs::file_type::directory) {
+            IterateDirEntriesRecursively(entry.path(), callback, filter);
+        }
+    }
+
+    if (callback_error || ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to visit all the directory entries of path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return;
+    }
+
+    LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
+              PathToUTF8String(path));
+}
+
+// Generic Filesystem Operations
+
+bool Exists(const fs::path& path) {
+    return fs::exists(path);
+}
+
+bool IsFile(const fs::path& path) {
+    return fs::is_regular_file(path);
+}
+
+bool IsDir(const fs::path& path) {
+    return fs::is_directory(path);
+}
+
+fs::path GetCurrentDir() {
+    std::error_code ec;
+
+    const auto current_path = fs::current_path(ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to get the current path, ec_message={}", ec.message());
+        return {};
+    }
+
+    return current_path;
+}
+
+bool SetCurrentDir(const fs::path& path) {
+    std::error_code ec;
+
+    fs::current_path(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to set the current path to path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return false;
+    }
+
+    return true;
+}
+
+fs::file_type GetEntryType(const fs::path& path) {
+    std::error_code ec;
+
+    const auto file_status = fs::status(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to retrieve the entry type of path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return fs::file_type::not_found;
+    }
+
+    return file_status.type();
+}
+
+u64 GetSize(const fs::path& path) {
+    std::error_code ec;
+
+    const auto file_size = fs::file_size(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return 0;
+    }
+
+    return file_size;
+}
+
+u64 GetFreeSpaceSize(const fs::path& path) {
+    std::error_code ec;
+
+    const auto space_info = fs::space(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to retrieve the available free space of path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return 0;
+    }
+
+    return space_info.free;
+}
+
+u64 GetTotalSpaceSize(const fs::path& path) {
+    std::error_code ec;
+
+    const auto space_info = fs::space(path, ec);
+
+    if (ec) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to retrieve the total capacity of path={}, ec_message={}",
+                  PathToUTF8String(path), ec.message());
+        return 0;
+    }
+
+    return space_info.capacity;
+}
+
+} // namespace Common::FS

src/common/fs/fs.h

@@ -0,0 +1,582 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <filesystem>
+#include <memory>
+
+#include "common/fs/fs_types.h"
+#include "common/fs/fs_util.h"
+
+namespace Common::FS {
+
+class IOFile;
+
+// File Operations
+
+/**
+ * Creates a new file at path with the specified size.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - The input path's parent directory does not exist
+ * - Filesystem object at path exists
+ * - Filesystem at path is read only
+ *
+ * @param path Filesystem path
+ * @param size File size
+ *
+ * @returns True if the file creation succeeds, false otherwise.
+ */
+[[nodiscard]] bool NewFile(const std::filesystem::path& path, u64 size = 0);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool NewFile(const Path& path, u64 size = 0) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return NewFile(ToU8String(path), size);
+    } else {
+        return NewFile(std::filesystem::path{path}, size);
+    }
+}
+#endif
+
+/**
+ * Removes a file at path.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem object at path is not a file
+ * - Filesystem at path is read only
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if file removal succeeds or file does not exist, false otherwise.
+ */
+[[nodiscard]] bool RemoveFile(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool RemoveFile(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return RemoveFile(ToU8String(path));
+    } else {
+        return RemoveFile(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Renames a file from old_path to new_path.
+ *
+ * Failures occur when:
+ * - One or both input path(s) is not valid
+ * - Filesystem object at old_path does not exist
+ * - Filesystem object at old_path is not a file
+ * - Filesystem object at new_path exists
+ * - Filesystem at either path is read only
+ *
+ * @param old_path Old filesystem path
+ * @param new_path New filesystem path
+ *
+ * @returns True if file rename succeeds, false otherwise.
+ */
+[[nodiscard]] bool RenameFile(const std::filesystem::path& old_path,
+                              const std::filesystem::path& new_path);
+
+#ifdef _WIN32
+template <typename Path1, typename Path2>
+[[nodiscard]] bool RenameFile(const Path1& old_path, const Path2& new_path) {
+    using ValueType1 = typename Path1::value_type;
+    using ValueType2 = typename Path2::value_type;
+    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
+        return RenameFile(ToU8String(old_path), ToU8String(new_path));
+    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
+        return RenameFile(ToU8String(old_path), new_path);
+    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
+        return RenameFile(old_path, ToU8String(new_path));
+    } else {
+        return RenameFile(std::filesystem::path{old_path}, std::filesystem::path{new_path});
+    }
+}
+#endif
+
+/**
+ * Opens a file at path with the specified file access mode.
+ * This function behaves differently depending on the FileAccessMode.
+ * These behaviors are documented in each enum value of FileAccessMode.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem object at path is not a file
+ * - The file is not opened
+ *
+ * @param path Filesystem path
+ * @param mode File access mode
+ * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
+ * @param flag (Windows only) File-share access flag, default is ShareReadOnly
+ *
+ * @returns A shared pointer to the opened file. Returns nullptr on failure.
+ */
+[[nodiscard]] std::shared_ptr<IOFile> FileOpen(const std::filesystem::path& path,
+                                               FileAccessMode mode,
+                                               FileType type = FileType::BinaryFile,
+                                               FileShareFlag flag = FileShareFlag::ShareReadOnly);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] std::shared_ptr<IOFile> FileOpen(const Path& path, FileAccessMode mode,
+                                               FileType type = FileType::BinaryFile,
+                                               FileShareFlag flag = FileShareFlag::ShareReadOnly) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return FileOpen(ToU8String(path), mode, type, flag);
+    } else {
+        return FileOpen(std::filesystem::path{path}, mode, type, flag);
+    }
+}
+#endif
+
+// Directory Operations
+
+/**
+ * Creates a directory at path.
+ * Note that this function will *always* assume that the input path is a directory. For example,
+ * if the input path is /path/to/directory/file.txt, it will create a directory called "file.txt".
+ * If you intend to create the parent directory of a file, use CreateParentDir instead.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - The input path's parent directory does not exist
+ * - Filesystem at path is read only
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if directory creation succeeds or directory already exists, false otherwise.
+ */
+[[nodiscard]] bool CreateDir(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool CreateDir(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return CreateDir(ToU8String(path));
+    } else {
+        return CreateDir(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Recursively creates a directory at path.
+ * Note that this function will *always* assume that the input path is a directory. For example,
+ * if the input path is /path/to/directory/file.txt, it will create a directory called "file.txt".
+ * If you intend to create the parent directory of a file, use CreateParentDirs instead.
+ * Unlike CreateDir, this creates all of input path's parent directories if they do not exist.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem at path is read only
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if directory creation succeeds or directory already exists, false otherwise.
+ */
+[[nodiscard]] bool CreateDirs(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool CreateDirs(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return CreateDirs(ToU8String(path));
+    } else {
+        return CreateDirs(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Creates the parent directory of a given path.
+ * This function calls CreateDir(path.parent_path()), see CreateDir for more details.
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if directory creation succeeds or directory already exists, false otherwise.
+ */
+[[nodiscard]] bool CreateParentDir(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool CreateParentDir(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return CreateParentDir(ToU8String(path));
+    } else {
+        return CreateParentDir(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Recursively creates the parent directory of a given path.
+ * This function calls CreateDirs(path.parent_path()), see CreateDirs for more details.
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if directory creation succeeds or directory already exists, false otherwise.
+ */
+[[nodiscard]] bool CreateParentDirs(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool CreateParentDirs(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return CreateParentDirs(ToU8String(path));
+    } else {
+        return CreateParentDirs(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Removes a directory at path.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem object at path is not a directory
+ * - The given directory is not empty
+ * - Filesystem at path is read only
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if directory removal succeeds or directory does not exist, false otherwise.
+ */
+[[nodiscard]] bool RemoveDir(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool RemoveDir(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return RemoveDir(ToU8String(path));
+    } else {
+        return RemoveDir(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Removes all the contents within the given directory and removes the directory itself.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem object at path is not a directory
+ * - Filesystem at path is read only
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if the directory and all of its contents are removed successfully, false otherwise.
+ */
+[[nodiscard]] bool RemoveDirRecursively(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool RemoveDirRecursively(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return RemoveDirRecursively(ToU8String(path));
+    } else {
+        return RemoveDirRecursively(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Removes all the contents within the given directory without removing the directory itself.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem object at path is not a directory
+ * - Filesystem at path is read only
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if all of the directory's contents are removed successfully, false otherwise.
+ */
+[[nodiscard]] bool RemoveDirContentsRecursively(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool RemoveDirContentsRecursively(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return RemoveDirContentsRecursively(ToU8String(path));
+    } else {
+        return RemoveDirContentsRecursively(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Renames a directory from old_path to new_path.
+ *
+ * Failures occur when:
+ * - One or both input path(s) is not valid
+ * - Filesystem object at old_path does not exist
+ * - Filesystem object at old_path is not a directory
+ * - Filesystem object at new_path exists
+ * - Filesystem at either path is read only
+ *
+ * @param old_path Old filesystem path
+ * @param new_path New filesystem path
+ *
+ * @returns True if directory rename succeeds, false otherwise.
+ */
+[[nodiscard]] bool RenameDir(const std::filesystem::path& old_path,
+                             const std::filesystem::path& new_path);
+
+#ifdef _WIN32
+template <typename Path1, typename Path2>
+[[nodiscard]] bool RenameDir(const Path1& old_path, const Path2& new_path) {
+    using ValueType1 = typename Path1::value_type;
+    using ValueType2 = typename Path2::value_type;
+    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
+        return RenameDir(ToU8String(old_path), ToU8String(new_path));
+    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
+        return RenameDir(ToU8String(old_path), new_path);
+    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
+        return RenameDir(old_path, ToU8String(new_path));
+    } else {
+        return RenameDir(std::filesystem::path{old_path}, std::filesystem::path{new_path});
+    }
+}
+#endif
+
+/**
+ * Iterates over the directory entries of a given directory.
+ * This does not iterate over the sub-directories of the given directory.
+ * The DirEntryCallable callback is called for each visited directory entry.
+ * A filter can be set to control which directory entries are visited based on their type.
+ * By default, both files and directories are visited.
+ * If the callback returns false or there is an error, the iteration is immediately halted.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem object at path is not a directory
+ *
+ * @param path Filesystem path
+ * @param callback Callback to be called for each visited directory entry
+ * @param filter Directory entry type filter
+ */
+void IterateDirEntries(const std::filesystem::path& path, const DirEntryCallable& callback,
+                       DirEntryFilter filter = DirEntryFilter::All);
+
+#ifdef _WIN32
+template <typename Path>
+void IterateDirEntries(const Path& path, const DirEntryCallable& callback,
+                       DirEntryFilter filter = DirEntryFilter::All) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        IterateDirEntries(ToU8String(path), callback, filter);
+    } else {
+        IterateDirEntries(std::filesystem::path{path}, callback, filter);
+    }
+}
+#endif
+
+/**
+ * Iterates over the directory entries of a given directory and its sub-directories.
+ * The DirEntryCallable callback is called for each visited directory entry.
+ * A filter can be set to control which directory entries are visited based on their type.
+ * By default, both files and directories are visited.
+ * If the callback returns false or there is an error, the iteration is immediately halted.
+ *
+ * Failures occur when:
+ * - Input path is not valid
+ * - Filesystem object at path does not exist
+ * - Filesystem object at path is not a directory
+ *
+ * @param path Filesystem path
+ * @param callback Callback to be called for each visited directory entry
+ * @param filter Directory entry type filter
+ */
+void IterateDirEntriesRecursively(const std::filesystem::path& path,
+                                  const DirEntryCallable& callback,
+                                  DirEntryFilter filter = DirEntryFilter::All);
+
+#ifdef _WIN32
+template <typename Path>
+void IterateDirEntriesRecursively(const Path& path, const DirEntryCallable& callback,
+                                  DirEntryFilter filter = DirEntryFilter::All) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        IterateDirEntriesRecursively(ToU8String(path), callback, filter);
+    } else {
+        IterateDirEntriesRecursively(std::filesystem::path{path}, callback, filter);
+    }
+}
+#endif
+
+// Generic Filesystem Operations
+
+/**
+ * Returns whether a filesystem object at path exists.
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if a filesystem object at path exists, false otherwise.
+ */
+[[nodiscard]] bool Exists(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool Exists(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return Exists(ToU8String(path));
+    } else {
+        return Exists(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Returns whether a filesystem object at path is a file.
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if a filesystem object at path is a file, false otherwise.
+ */
+[[nodiscard]] bool IsFile(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool IsFile(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return IsFile(ToU8String(path));
+    } else {
+        return IsFile(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Returns whether a filesystem object at path is a directory.
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if a filesystem object at path is a directory, false otherwise.
+ */
+[[nodiscard]] bool IsDir(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool IsDir(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return IsDir(ToU8String(path));
+    } else {
+        return IsDir(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Gets the current working directory.
+ *
+ * @returns The current working directory. Returns an empty path on failure.
+ */
+[[nodiscard]] std::filesystem::path GetCurrentDir();
+
+/**
+ * Sets the current working directory to path.
+ *
+ * @returns True if the current working directory is successfully set, false otherwise.
+ */
+[[nodiscard]] bool SetCurrentDir(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool SetCurrentDir(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return SetCurrentDir(ToU8String(path));
+    } else {
+        return SetCurrentDir(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Gets the entry type of the filesystem object at path.
+ *
+ * @param path Filesystem path
+ *
+ * @returns The entry type of the filesystem object. Returns file_type::not_found on failure.
+ */
+[[nodiscard]] std::filesystem::file_type GetEntryType(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] std::filesystem::file_type GetEntryType(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return GetEntryType(ToU8String(path));
+    } else {
+        return GetEntryType(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Gets the size of the filesystem object at path.
+ *
+ * @param path Filesystem path
+ *
+ * @returns The size in bytes of the filesystem object. Returns 0 on failure.
+ */
+[[nodiscard]] u64 GetSize(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] u64 GetSize(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return GetSize(ToU8String(path));
+    } else {
+        return GetSize(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Gets the free space size of the filesystem at path.
+ *
+ * @param path Filesystem path
+ *
+ * @returns The free space size in bytes of the filesystem at path. Returns 0 on failure.
+ */
+[[nodiscard]] u64 GetFreeSpaceSize(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] u64 GetFreeSpaceSize(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return GetFreeSpaceSize(ToU8String(path));
+    } else {
+        return GetFreeSpaceSize(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Gets the total capacity of the filesystem at path.
+ *
+ * @param path Filesystem path
+ *
+ * @returns The total capacity in bytes of the filesystem at path. Returns 0 on failure.
+ */
+[[nodiscard]] u64 GetTotalSpaceSize(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] u64 GetTotalSpaceSize(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return GetTotalSpaceSize(ToU8String(path));
+    } else {
+        return GetTotalSpaceSize(std::filesystem::path{path});
+    }
+}
+#endif
+
+} // namespace Common::FS

src/common/fs/fs_paths.h

@@ -0,0 +1,27 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+// yuzu data directories
+
+#define YUZU_DIR "yuzu"
+#define PORTABLE_DIR "user"
+
+// Sub-directories contained within a yuzu data directory
+
+#define CACHE_DIR "cache"
+#define CONFIG_DIR "config"
+#define DUMP_DIR "dump"
+#define KEYS_DIR "keys"
+#define LOAD_DIR "load"
+#define LOG_DIR "log"
+#define NAND_DIR "nand"
+#define SCREENSHOTS_DIR "screenshots"
+#define SDMC_DIR "sdmc"
+#define SHADER_DIR "shader"
+
+// yuzu-specific files
+
+#define LOG_FILE "yuzu_log.txt"

src/common/fs/fs_types.h

@@ -0,0 +1,73 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+
+namespace Common::FS {
+
+enum class FileAccessMode {
+    /**
+     * If the file at path exists, it opens the file for reading.
+     * If the file at path does not exist, it fails to open the file.
+     */
+    Read = 1 << 0,
+    /**
+     * If the file at path exists, the existing contents of the file are erased.
+     * The empty file is then opened for writing.
+     * If the file at path does not exist, it creates and opens a new empty file for writing.
+     */
+    Write = 1 << 1,
+    /**
+     * If the file at path exists, it opens the file for reading and writing.
+     * If the file at path does not exist, it fails to open the file.
+     */
+    ReadWrite = Read | Write,
+    /**
+     * If the file at path exists, it opens the file for appending.
+     * If the file at path does not exist, it creates and opens a new empty file for appending.
+     */
+    Append = 1 << 2,
+    /**
+     * If the file at path exists, it opens the file for both reading and appending.
+     * If the file at path does not exist, it creates and opens a new empty file for both
+     * reading and appending.
+     */
+    ReadAppend = Read | Append,
+};
+
+enum class FileType {
+    BinaryFile,
+    TextFile,
+};
+
+enum class FileShareFlag {
+    ShareNone,      // Provides exclusive access to the file.
+    ShareReadOnly,  // Provides read only shared access to the file.
+    ShareWriteOnly, // Provides write only shared access to the file.
+    ShareReadWrite, // Provides read and write shared access to the file.
+};
+
+enum class DirEntryFilter {
+    File = 1 << 0,
+    Directory = 1 << 1,
+    All = File | Directory,
+};
+DECLARE_ENUM_FLAG_OPERATORS(DirEntryFilter);
+
+/**
+ * A callback function which takes in the path of a directory entry.
+ *
+ * @param path The path of a directory entry
+ *
+ * @returns A boolean value.
+ *          Return true to indicate whether the callback is successful, false otherwise.
+ */
+using DirEntryCallable = std::function<bool(const std::filesystem::path& path)>;
+
+} // namespace Common::FS

src/common/fs/fs_util.cpp

@@ -0,0 +1,27 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+
+#include "common/fs/fs_util.h"
+
+namespace Common::FS {
+
+std::u8string ToU8String(std::string_view utf8_string) {
+    return std::u8string{utf8_string.begin(), utf8_string.end()};
+}
+
+std::u8string BufferToU8String(std::span<const u8> buffer) {
+    return std::u8string{buffer.begin(), std::ranges::find(buffer, u8{0})};
+}
+
+std::string ToUTF8String(std::u8string_view u8_string) {
+    return std::string{u8_string.begin(), u8_string.end()};
+}
+
+std::string PathToUTF8String(const std::filesystem::path& path) {
+    return ToUTF8String(path.u8string());
+}
+
+} // namespace Common::FS

src/common/fs/fs_util.h

@@ -0,0 +1,58 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <concepts>
+#include <filesystem>
+#include <span>
+#include <string>
+#include <string_view>
+
+#include "common/common_types.h"
+
+namespace Common::FS {
+
+template <typename T>
+concept IsChar = std::same_as<T, char>;
+
+/**
+ * Converts a UTF-8 encoded std::string or std::string_view to a std::u8string.
+ *
+ * @param utf8_string UTF-8 encoded string
+ *
+ * @returns UTF-8 encoded std::u8string.
+ */
+[[nodiscard]] std::u8string ToU8String(std::string_view utf8_string);
+
+/**
+ * Converts a buffer of bytes to a UTF8-encoded std::u8string.
+ * This converts from the start of the buffer until the first encountered null-terminator.
+ * If no null-terminator is found, this converts the entire buffer instead.
+ *
+ * @param buffer Buffer of bytes
+ *
+ * @returns UTF-8 encoded std::u8string.
+ */
+[[nodiscard]] std::u8string BufferToU8String(std::span<const u8> buffer);
+
+/**
+ * Converts a std::u8string or std::u8string_view to a UTF-8 encoded std::string.
+ *
+ * @param u8_string UTF-8 encoded u8string
+ *
+ * @returns UTF-8 encoded std::string.
+ */
+[[nodiscard]] std::string ToUTF8String(std::u8string_view u8_string);
+
+/**
+ * Converts a filesystem path to a UTF-8 encoded std::string.
+ *
+ * @param path Filesystem path
+ *
+ * @returns UTF-8 encoded std::string.
+ */
+[[nodiscard]] std::string PathToUTF8String(const std::filesystem::path& path);
+
+} // namespace Common::FS

src/common/fs/path_util.cpp

@@ -0,0 +1,426 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <unordered_map>
+
+#include "common/fs/fs.h"
+#include "common/fs/fs_paths.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+
+#ifdef _WIN32
+#include <shlobj.h> // Used in GetExeDirectory()
+#else
+#include <cstdlib>     // Used in Get(Home/Data)Directory()
+#include <pwd.h>       // Used in GetHomeDirectory()
+#include <sys/types.h> // Used in GetHomeDirectory()
+#include <unistd.h>    // Used in GetDataDirectory()
+#endif
+
+#ifdef __APPLE__
+#include <sys/param.h> // Used in GetBundleDirectory()
+
+// CFURL contains __attribute__ directives that gcc does not know how to parse, so we need to just
+// ignore them if we're not using clang. The macro is only used to prevent linking against
+// functions that don't exist on older versions of macOS, and the worst case scenario is a linker
+// error, so this is perfectly safe, just inconvenient.
+#ifndef __clang__
+#define availability(...)
+#endif
+#include <CoreFoundation/CFBundle.h> // Used in GetBundleDirectory()
+#include <CoreFoundation/CFString.h> // Used in GetBundleDirectory()
+#include <CoreFoundation/CFURL.h>    // Used in GetBundleDirectory()
+#ifdef availability
+#undef availability
+#endif
+#endif
+
+#ifndef MAX_PATH
+#ifdef _WIN32
+// This is the maximum number of UTF-16 code units permissible in Windows file paths
+#define MAX_PATH 260
+#else
+// This is the maximum number of UTF-8 code units permissible in all other OSes' file paths
+#define MAX_PATH 1024
+#endif
+#endif
+
+namespace Common::FS {
+
+namespace fs = std::filesystem;
+
+/**
+ * The PathManagerImpl is a singleton allowing to manage the mapping of
+ * YuzuPath enums to real filesystem paths.
+ * This class provides 2 functions: GetYuzuPathImpl and SetYuzuPathImpl.
+ * These are used by GetYuzuPath and SetYuzuPath respectively to get or modify
+ * the path mapped by the YuzuPath enum.
+ */
+class PathManagerImpl {
+public:
+    static PathManagerImpl& GetInstance() {
+        static PathManagerImpl path_manager_impl;
+
+        return path_manager_impl;
+    }
+
+    PathManagerImpl(const PathManagerImpl&) = delete;
+    PathManagerImpl& operator=(const PathManagerImpl&) = delete;
+
+    PathManagerImpl(PathManagerImpl&&) = delete;
+    PathManagerImpl& operator=(PathManagerImpl&&) = delete;
+
+    [[nodiscard]] const fs::path& GetYuzuPathImpl(YuzuPath yuzu_path) {
+        return yuzu_paths.at(yuzu_path);
+    }
+
+    void SetYuzuPathImpl(YuzuPath yuzu_path, const fs::path& new_path) {
+        yuzu_paths.insert_or_assign(yuzu_path, new_path);
+    }
+
+private:
+    PathManagerImpl() {
+#ifdef _WIN32
+        auto yuzu_path = GetExeDirectory() / PORTABLE_DIR;
+
+        if (!IsDir(yuzu_path)) {
+            yuzu_path = GetAppDataRoamingDirectory() / YUZU_DIR;
+        }
+
+        GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
+        GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path / CACHE_DIR);
+        GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path / CONFIG_DIR);
+#else
+        auto yuzu_path = GetCurrentDir() / PORTABLE_DIR;
+
+        if (Exists(yuzu_path) && IsDir(yuzu_path)) {
+            GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
+            GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path / CACHE_DIR);
+            GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path / CONFIG_DIR);
+        } else {
+            yuzu_path = GetDataDirectory("XDG_DATA_HOME") / YUZU_DIR;
+
+            GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
+            GenerateYuzuPath(YuzuPath::CacheDir, GetDataDirectory("XDG_CACHE_HOME") / YUZU_DIR);
+            GenerateYuzuPath(YuzuPath::ConfigDir, GetDataDirectory("XDG_CONFIG_HOME") / YUZU_DIR);
+        }
+#endif
+
+        GenerateYuzuPath(YuzuPath::DumpDir, yuzu_path / DUMP_DIR);
+        GenerateYuzuPath(YuzuPath::KeysDir, yuzu_path / KEYS_DIR);
+        GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);
+        GenerateYuzuPath(YuzuPath::LogDir, yuzu_path / LOG_DIR);
+        GenerateYuzuPath(YuzuPath::NANDDir, yuzu_path / NAND_DIR);
+        GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
+        GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
+        GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);
+    }
+
+    ~PathManagerImpl() = default;
+
+    void GenerateYuzuPath(YuzuPath yuzu_path, const fs::path& new_path) {
+        void(FS::CreateDir(new_path));
+
+        SetYuzuPathImpl(yuzu_path, new_path);
+    }
+
+    std::unordered_map<YuzuPath, fs::path> yuzu_paths;
+};
+
+bool ValidatePath(const fs::path& path) {
+    if (path.empty()) {
+        LOG_ERROR(Common_Filesystem, "Input path is empty, path={}", PathToUTF8String(path));
+        return false;
+    }
+
+#ifdef _WIN32
+    if (path.u16string().size() >= MAX_PATH) {
+        LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
+        return false;
+    }
+#else
+    if (path.u8string().size() >= MAX_PATH) {
+        LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
+        return false;
+    }
+#endif
+
+    return true;
+}
+
+fs::path ConcatPath(const fs::path& first, const fs::path& second) {
+    const bool second_has_dir_sep = IsDirSeparator(second.u8string().front());
+
+    if (!second_has_dir_sep) {
+        return (first / second).lexically_normal();
+    }
+
+    fs::path concat_path = first;
+    concat_path += second;
+
+    return concat_path.lexically_normal();
+}
+
+fs::path ConcatPathSafe(const fs::path& base, const fs::path& offset) {
+    const auto concatenated_path = ConcatPath(base, offset);
+
+    if (!IsPathSandboxed(base, concatenated_path)) {
+        return base;
+    }
+
+    return concatenated_path;
+}
+
+bool IsPathSandboxed(const fs::path& base, const fs::path& path) {
+    const auto base_string = RemoveTrailingSeparators(base.lexically_normal()).u8string();
+    const auto path_string = RemoveTrailingSeparators(path.lexically_normal()).u8string();
+
+    if (path_string.size() < base_string.size()) {
+        return false;
+    }
+
+    return base_string.compare(0, base_string.size(), path_string, 0, base_string.size()) == 0;
+}
+
+bool IsDirSeparator(char character) {
+    return character == '/' || character == '\\';
+}
+
+bool IsDirSeparator(char8_t character) {
+    return character == u8'/' || character == u8'\\';
+}
+
+fs::path RemoveTrailingSeparators(const fs::path& path) {
+    if (path.empty()) {
+        return path;
+    }
+
+    auto string_path = path.u8string();
+
+    while (IsDirSeparator(string_path.back())) {
+        string_path.pop_back();
+    }
+
+    return fs::path{string_path};
+}
+
+const fs::path& GetYuzuPath(YuzuPath yuzu_path) {
+    return PathManagerImpl::GetInstance().GetYuzuPathImpl(yuzu_path);
+}
+
+std::string GetYuzuPathString(YuzuPath yuzu_path) {
+    return PathToUTF8String(GetYuzuPath(yuzu_path));
+}
+
+void SetYuzuPath(YuzuPath yuzu_path, const fs::path& new_path) {
+    if (!FS::IsDir(new_path)) {
+        LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} is not a directory",
+                  PathToUTF8String(new_path));
+        return;
+    }
+
+    PathManagerImpl::GetInstance().SetYuzuPathImpl(yuzu_path, new_path);
+}
+
+#ifdef _WIN32
+
+fs::path GetExeDirectory() {
+    wchar_t exe_path[MAX_PATH];
+
+    GetModuleFileNameW(nullptr, exe_path, MAX_PATH);
+
+    if (!exe_path) {
+        LOG_ERROR(Common_Filesystem,
+                  "Failed to get the path to the executable of the current process");
+    }
+
+    return fs::path{exe_path}.parent_path();
+}
+
+fs::path GetAppDataRoamingDirectory() {
+    PWSTR appdata_roaming_path = nullptr;
+
+    SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &appdata_roaming_path);
+
+    auto fs_appdata_roaming_path = fs::path{appdata_roaming_path};
+
+    CoTaskMemFree(appdata_roaming_path);
+
+    if (fs_appdata_roaming_path.empty()) {
+        LOG_ERROR(Common_Filesystem, "Failed to get the path to the %APPDATA% directory");
+    }
+
+    return fs_appdata_roaming_path;
+}
+
+#else
+
+fs::path GetHomeDirectory() {
+    const char* home_env_var = getenv("HOME");
+
+    if (home_env_var) {
+        return fs::path{home_env_var};
+    }
+
+    LOG_INFO(Common_Filesystem,
+             "$HOME is not defined in the environment variables, "
+             "attempting to query passwd to get the home path of the current user");
+
+    const auto* pw = getpwuid(getuid());
+
+    if (!pw) {
+        LOG_ERROR(Common_Filesystem, "Failed to get the home path of the current user");
+        return {};
+    }
+
+    return fs::path{pw->pw_dir};
+}
+
+fs::path GetDataDirectory(const std::string& env_name) {
+    const char* data_env_var = getenv(env_name.c_str());
+
+    if (data_env_var) {
+        return fs::path{data_env_var};
+    }
+
+    if (env_name == "XDG_DATA_HOME") {
+        return GetHomeDirectory() / ".local/share";
+    } else if (env_name == "XDG_CACHE_HOME") {
+        return GetHomeDirectory() / ".cache";
+    } else if (env_name == "XDG_CONFIG_HOME") {
+        return GetHomeDirectory() / ".config";
+    }
+
+    return {};
+}
+
+#endif
+
+#ifdef __APPLE__
+
+fs::path GetBundleDirectory() {
+    char app_bundle_path[MAXPATHLEN];
+
+    // Get the main bundle for the app
+    CFURLRef bundle_ref = CFBundleCopyBundleURL(CFBundleGetMainBundle());
+    CFStringRef bundle_path = CFURLCopyFileSystemPath(bundle_ref, kCFURLPOSIXPathStyle);
+
+    CFStringGetFileSystemRepresentation(bundle_path, app_bundle_path, sizeof(app_bundle_path));
+
+    CFRelease(bundle_ref);
+    CFRelease(bundle_path);
+
+    return fs::path{app_bundle_path};
+}
+
+#endif
+
+// vvvvvvvvvv Deprecated vvvvvvvvvv //
+
+std::string_view RemoveTrailingSlash(std::string_view path) {
+    if (path.empty()) {
+        return path;
+    }
+
+    if (path.back() == '\\' || path.back() == '/') {
+        path.remove_suffix(1);
+        return path;
+    }
+
+    return path;
+}
+
+std::vector<std::string> SplitPathComponents(std::string_view filename) {
+    std::string copy(filename);
+    std::replace(copy.begin(), copy.end(), '\\', '/');
+    std::vector<std::string> out;
+
+    std::stringstream stream(copy);
+    std::string item;
+    while (std::getline(stream, item, '/')) {
+        out.push_back(std::move(item));
+    }
+
+    return out;
+}
+
+std::string SanitizePath(std::string_view path_, DirectorySeparator directory_separator) {
+    std::string path(path_);
+    char type1 = directory_separator == DirectorySeparator::BackwardSlash ? '/' : '\\';
+    char type2 = directory_separator == DirectorySeparator::BackwardSlash ? '\\' : '/';
+
+    if (directory_separator == DirectorySeparator::PlatformDefault) {
+#ifdef _WIN32
+        type1 = '/';
+        type2 = '\\';
+#endif
+    }
+
+    std::replace(path.begin(), path.end(), type1, type2);
+
+    auto start = path.begin();
+#ifdef _WIN32
+    // allow network paths which start with a double backslash (e.g. \\server\share)
+    if (start != path.end())
+        ++start;
+#endif
+    path.erase(std::unique(start, path.end(),
+                           [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
+               path.end());
+    return std::string(RemoveTrailingSlash(path));
+}
+
+std::string_view GetParentPath(std::string_view path) {
+    const auto name_bck_index = path.rfind('\\');
+    const auto name_fwd_index = path.rfind('/');
+    std::size_t name_index;
+
+    if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
+        name_index = std::min(name_bck_index, name_fwd_index);
+    } else {
+        name_index = std::max(name_bck_index, name_fwd_index);
+    }
+
+    return path.substr(0, name_index);
+}
+
+std::string_view GetPathWithoutTop(std::string_view path) {
+    if (path.empty()) {
+        return path;
+    }
+
+    while (path[0] == '\\' || path[0] == '/') {
+        path.remove_prefix(1);
+        if (path.empty()) {
+            return path;
+        }
+    }
+
+    const auto name_bck_index = path.find('\\');
+    const auto name_fwd_index = path.find('/');
+    return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
+}
+
+std::string_view GetFilename(std::string_view path) {
+    const auto name_index = path.find_last_of("\\/");
+
+    if (name_index == std::string_view::npos) {
+        return {};
+    }
+
+    return path.substr(name_index + 1);
+}
+
+std::string_view GetExtensionFromFilename(std::string_view name) {
+    const std::size_t index = name.rfind('.');
+
+    if (index == std::string_view::npos) {
+        return {};
+    }
+
+    return name.substr(index + 1);
+}
+
+} // namespace Common::FS

src/common/fs/path_util.h

@@ -0,0 +1,300 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <filesystem>
+#include <vector>
+
+#include "common/fs/fs_util.h"
+
+namespace Common::FS {
+
+enum class YuzuPath {
+    YuzuDir,        // Where yuzu stores its data.
+    CacheDir,       // Where cached filesystem data is stored.
+    ConfigDir,      // Where config files are stored.
+    DumpDir,        // Where dumped data is stored.
+    KeysDir,        // Where key files are stored.
+    LoadDir,        // Where cheat/mod files are stored.
+    LogDir,         // Where log files are stored.
+    NANDDir,        // Where the emulated NAND is stored.
+    ScreenshotsDir, // Where yuzu screenshots are stored.
+    SDMCDir,        // Where the emulated SDMC is stored.
+    ShaderDir,      // Where shaders are stored.
+};
+
+/**
+ * Validates a given path.
+ *
+ * A given path is valid if it meets these conditions:
+ * - The path is not empty
+ * - The path is not too long
+ *
+ * @param path Filesystem path
+ *
+ * @returns True if the path is valid, false otherwise.
+ */
+[[nodiscard]] bool ValidatePath(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] bool ValidatePath(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return ValidatePath(ToU8String(path));
+    } else {
+        return ValidatePath(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Concatenates two filesystem paths together.
+ *
+ * This is needed since the following occurs when using std::filesystem::path's operator/:
+ * first: "/first/path"
+ * second: "/second/path" (Note that the second path has a directory separator in the front)
+ * first / second yields "/second/path" when the desired result is first/path/second/path
+ *
+ * @param first First filesystem path
+ * @param second Second filesystem path
+ *
+ * @returns A concatenated filesystem path.
+ */
+[[nodiscard]] std::filesystem::path ConcatPath(const std::filesystem::path& first,
+                                               const std::filesystem::path& second);
+
+#ifdef _WIN32
+template <typename Path1, typename Path2>
+[[nodiscard]] std::filesystem::path ConcatPath(const Path1& first, const Path2& second) {
+    using ValueType1 = typename Path1::value_type;
+    using ValueType2 = typename Path2::value_type;
+    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
+        return ConcatPath(ToU8String(first), ToU8String(second));
+    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
+        return ConcatPath(ToU8String(first), second);
+    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
+        return ConcatPath(first, ToU8String(second));
+    } else {
+        return ConcatPath(std::filesystem::path{first}, std::filesystem::path{second});
+    }
+}
+#endif
+
+/**
+ * Safe variant of ConcatPath that takes in a base path and an offset path from the given base path.
+ *
+ * If ConcatPath(base, offset) resolves to a path that is sandboxed within the base path,
+ * this will return the concatenated path. Otherwise this will return the base path.
+ *
+ * @param base Base filesystem path
+ * @param offset Offset filesystem path
+ *
+ * @returns A concatenated filesystem path if it is within the base path,
+ *          returns the base path otherwise.
+ */
+[[nodiscard]] std::filesystem::path ConcatPathSafe(const std::filesystem::path& base,
+                                                   const std::filesystem::path& offset);
+
+#ifdef _WIN32
+template <typename Path1, typename Path2>
+[[nodiscard]] std::filesystem::path ConcatPathSafe(const Path1& base, const Path2& offset) {
+    using ValueType1 = typename Path1::value_type;
+    using ValueType2 = typename Path2::value_type;
+    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
+        return ConcatPathSafe(ToU8String(base), ToU8String(offset));
+    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
+        return ConcatPathSafe(ToU8String(base), offset);
+    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
+        return ConcatPathSafe(base, ToU8String(offset));
+    } else {
+        return ConcatPathSafe(std::filesystem::path{base}, std::filesystem::path{offset});
+    }
+}
+#endif
+
+/**
+ * Checks whether a given path is sandboxed within a given base path.
+ *
+ * @param base Base filesystem path
+ * @param path Filesystem path
+ *
+ * @returns True if the given path is sandboxed within the given base path, false otherwise.
+ */
+[[nodiscard]] bool IsPathSandboxed(const std::filesystem::path& base,
+                                   const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path1, typename Path2>
+[[nodiscard]] bool IsPathSandboxed(const Path1& base, const Path2& path) {
+    using ValueType1 = typename Path1::value_type;
+    using ValueType2 = typename Path2::value_type;
+    if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
+        return IsPathSandboxed(ToU8String(base), ToU8String(path));
+    } else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
+        return IsPathSandboxed(ToU8String(base), path);
+    } else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
+        return IsPathSandboxed(base, ToU8String(path));
+    } else {
+        return IsPathSandboxed(std::filesystem::path{base}, std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Checks if a character is a directory separator (either a forward slash or backslash).
+ *
+ * @param character Character
+ *
+ * @returns True if the character is a directory separator, false otherwise.
+ */
+[[nodiscard]] bool IsDirSeparator(char character);
+
+/**
+ * Checks if a character is a directory separator (either a forward slash or backslash).
+ *
+ * @param character Character
+ *
+ * @returns True if the character is a directory separator, false otherwise.
+ */
+[[nodiscard]] bool IsDirSeparator(char8_t character);
+
+/**
+ * Removes any trailing directory separators if they exist in the given path.
+ *
+ * @param path Filesystem path
+ *
+ * @returns The filesystem path without any trailing directory separators.
+ */
+[[nodiscard]] std::filesystem::path RemoveTrailingSeparators(const std::filesystem::path& path);
+
+#ifdef _WIN32
+template <typename Path>
+[[nodiscard]] std::filesystem::path RemoveTrailingSeparators(const Path& path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        return RemoveTrailingSeparators(ToU8String(path));
+    } else {
+        return RemoveTrailingSeparators(std::filesystem::path{path});
+    }
+}
+#endif
+
+/**
+ * Gets the filesystem path associated with the YuzuPath enum.
+ *
+ * @param yuzu_path YuzuPath enum
+ *
+ * @returns The filesystem path associated with the YuzuPath enum.
+ */
+[[nodiscard]] const std::filesystem::path& GetYuzuPath(YuzuPath yuzu_path);
+
+/**
+ * Gets the filesystem path associated with the YuzuPath enum as a UTF-8 encoded std::string.
+ *
+ * @param yuzu_path YuzuPath enum
+ *
+ * @returns The filesystem path associated with the YuzuPath enum as a UTF-8 encoded std::string.
+ */
+[[nodiscard]] std::string GetYuzuPathString(YuzuPath yuzu_path);
+
+/**
+ * Sets a new filesystem path associated with the YuzuPath enum.
+ * If the filesystem object at new_path is not a directory, this function will not do anything.
+ *
+ * @param yuzu_path YuzuPath enum
+ * @param new_path New filesystem path
+ */
+void SetYuzuPath(YuzuPath yuzu_path, const std::filesystem::path& new_path);
+
+#ifdef _WIN32
+template <typename Path>
+void SetYuzuPath(YuzuPath yuzu_path, const Path& new_path) {
+    if constexpr (IsChar<typename Path::value_type>) {
+        SetYuzuPath(yuzu_path, ToU8String(new_path));
+    } else {
+        SetYuzuPath(yuzu_path, std::filesystem::path{new_path});
+    }
+}
+#endif
+
+#ifdef _WIN32
+
+/**
+ * Gets the path of the directory containing the executable of the current process.
+ *
+ * @returns The path of the directory containing the executable of the current process.
+ */
+[[nodiscard]] std::filesystem::path GetExeDirectory();
+
+/**
+ * Gets the path of the current user's %APPDATA% directory (%USERPROFILE%/AppData/Roaming).
+ *
+ * @returns The path of the current user's %APPDATA% directory.
+ */
+[[nodiscard]] std::filesystem::path GetAppDataRoamingDirectory();
+
+#else
+
+/**
+ * Gets the path of the directory specified by the #HOME environment variable.
+ * If $HOME is not defined, it will attempt to query the user database in passwd instead.
+ *
+ * @returns The path of the current user's home directory.
+ */
+[[nodiscard]] std::filesystem::path GetHomeDirectory();
+
+/**
+ * Gets the relevant paths for yuzu to store its data based on the given XDG environment variable.
+ * See https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+ * Defaults to $HOME/.local/share for main application data,
+ * $HOME/.cache for cached data, and $HOME/.config for configuration files.
+ *
+ * @param env_name XDG environment variable name
+ *
+ * @returns The path where yuzu should store its data.
+ */
+[[nodiscard]] std::filesystem::path GetDataDirectory(const std::string& env_name);
+
+#endif
+
+#ifdef __APPLE__
+
+[[nodiscard]] std::filesystem::path GetBundleDirectory();
+
+#endif
+
+// vvvvvvvvvv Deprecated vvvvvvvvvv //
+
+// Removes the final '/' or '\' if one exists
+[[nodiscard]] std::string_view RemoveTrailingSlash(std::string_view path);
+
+enum class DirectorySeparator {
+    ForwardSlash,
+    BackwardSlash,
+    PlatformDefault,
+};
+
+// Splits the path on '/' or '\' and put the components into a vector
+// i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
+[[nodiscard]] std::vector<std::string> SplitPathComponents(std::string_view filename);
+
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
+// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
+[[nodiscard]] std::string SanitizePath(
+    std::string_view path,
+    DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
+
+// Gets all of the text up to the last '/' or '\' in the path.
+[[nodiscard]] std::string_view GetParentPath(std::string_view path);
+
+// Gets all of the text after the first '/' or '\' in the path.
+[[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
+
+// Gets the filename of the path
+[[nodiscard]] std::string_view GetFilename(std::string_view path);
+
+// Gets the extension of the filename
+[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
+
+} // namespace Common::FS

src/common/host_memory.cpp

@@ -0,0 +1,538 @@
+#ifdef _WIN32
+
+#include <iterator>
+#include <unordered_map>
+#include <boost/icl/separate_interval_set.hpp>
+#include <windows.h>
+#include "common/dynamic_library.h"
+
+#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#endif // ^^^ Linux ^^^
+
+#include <mutex>
+
+#include "common/alignment.h"
+#include "common/assert.h"
+#include "common/host_memory.h"
+#include "common/logging/log.h"
+#include "common/scope_exit.h"
+
+namespace Common {
+
+constexpr size_t PageAlignment = 0x1000;
+constexpr size_t HugePageSize = 0x200000;
+
+#ifdef _WIN32
+
+// Manually imported for MinGW compatibility
+#ifndef MEM_RESERVE_PLACEHOLDER
+#define MEM_RESERVE_PLACEHOLDER 0x0004000
+#endif
+#ifndef MEM_REPLACE_PLACEHOLDER
+#define MEM_REPLACE_PLACEHOLDER 0x00004000
+#endif
+#ifndef MEM_COALESCE_PLACEHOLDERS
+#define MEM_COALESCE_PLACEHOLDERS 0x00000001
+#endif
+#ifndef MEM_PRESERVE_PLACEHOLDER
+#define MEM_PRESERVE_PLACEHOLDER 0x00000002
+#endif
+
+using PFN_CreateFileMapping2 = _Ret_maybenull_ HANDLE(WINAPI*)(
+    _In_ HANDLE File, _In_opt_ SECURITY_ATTRIBUTES* SecurityAttributes, _In_ ULONG DesiredAccess,
+    _In_ ULONG PageProtection, _In_ ULONG AllocationAttributes, _In_ ULONG64 MaximumSize,
+    _In_opt_ PCWSTR Name,
+    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
+    _In_ ULONG ParameterCount);
+
+using PFN_VirtualAlloc2 = _Ret_maybenull_ PVOID(WINAPI*)(
+    _In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress, _In_ SIZE_T Size,
+    _In_ ULONG AllocationType, _In_ ULONG PageProtection,
+    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
+    _In_ ULONG ParameterCount);
+
+using PFN_MapViewOfFile3 = _Ret_maybenull_ PVOID(WINAPI*)(
+    _In_ HANDLE FileMapping, _In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress,
+    _In_ ULONG64 Offset, _In_ SIZE_T ViewSize, _In_ ULONG AllocationType, _In_ ULONG PageProtection,
+    _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
+    _In_ ULONG ParameterCount);
+
+using PFN_UnmapViewOfFile2 = BOOL(WINAPI*)(_In_ HANDLE Process, _In_ PVOID BaseAddress,
+                                           _In_ ULONG UnmapFlags);
+
+template <typename T>
+static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn) {
+    if (!dll.GetSymbol(name, &pfn)) {
+        LOG_CRITICAL(HW_Memory, "Failed to load {}", name);
+        throw std::bad_alloc{};
+    }
+}
+
+class HostMemory::Impl {
+public:
+    explicit Impl(size_t backing_size_, size_t virtual_size_)
+        : backing_size{backing_size_}, virtual_size{virtual_size_}, process{GetCurrentProcess()},
+          kernelbase_dll("Kernelbase") {
+        if (!kernelbase_dll.IsOpen()) {
+            LOG_CRITICAL(HW_Memory, "Failed to load Kernelbase.dll");
+            throw std::bad_alloc{};
+        }
+        GetFuncAddress(kernelbase_dll, "CreateFileMapping2", pfn_CreateFileMapping2);
+        GetFuncAddress(kernelbase_dll, "VirtualAlloc2", pfn_VirtualAlloc2);
+        GetFuncAddress(kernelbase_dll, "MapViewOfFile3", pfn_MapViewOfFile3);
+        GetFuncAddress(kernelbase_dll, "UnmapViewOfFile2", pfn_UnmapViewOfFile2);
+
+        // Allocate backing file map
+        backing_handle =
+            pfn_CreateFileMapping2(INVALID_HANDLE_VALUE, nullptr, FILE_MAP_WRITE | FILE_MAP_READ,
+                                   PAGE_READWRITE, SEC_COMMIT, backing_size, nullptr, nullptr, 0);
+        if (!backing_handle) {
+            LOG_CRITICAL(HW_Memory, "Failed to allocate {} MiB of backing memory",
+                         backing_size >> 20);
+            throw std::bad_alloc{};
+        }
+        // Allocate a virtual memory for the backing file map as placeholder
+        backing_base = static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, backing_size,
+                                                          MEM_RESERVE | MEM_RESERVE_PLACEHOLDER,
+                                                          PAGE_NOACCESS, nullptr, 0));
+        if (!backing_base) {
+            Release();
+            LOG_CRITICAL(HW_Memory, "Failed to reserve {} MiB of virtual memory",
+                         backing_size >> 20);
+            throw std::bad_alloc{};
+        }
+        // Map backing placeholder
+        void* const ret = pfn_MapViewOfFile3(backing_handle, process, backing_base, 0, backing_size,
+                                             MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0);
+        if (ret != backing_base) {
+            Release();
+            LOG_CRITICAL(HW_Memory, "Failed to map {} MiB of virtual memory", backing_size >> 20);
+            throw std::bad_alloc{};
+        }
+        // Allocate virtual address placeholder
+        virtual_base = static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, virtual_size,
+                                                          MEM_RESERVE | MEM_RESERVE_PLACEHOLDER,
+                                                          PAGE_NOACCESS, nullptr, 0));
+        if (!virtual_base) {
+            Release();
+            LOG_CRITICAL(HW_Memory, "Failed to reserve {} GiB of virtual memory",
+                         virtual_size >> 30);
+            throw std::bad_alloc{};
+        }
+    }
+
+    ~Impl() {
+        Release();
+    }
+
+    void Map(size_t virtual_offset, size_t host_offset, size_t length) {
+        std::unique_lock lock{placeholder_mutex};
+        if (!IsNiechePlaceholder(virtual_offset, length)) {
+            Split(virtual_offset, length);
+        }
+        ASSERT(placeholders.find({virtual_offset, virtual_offset + length}) == placeholders.end());
+        TrackPlaceholder(virtual_offset, host_offset, length);
+
+        MapView(virtual_offset, host_offset, length);
+    }
+
+    void Unmap(size_t virtual_offset, size_t length) {
+        std::lock_guard lock{placeholder_mutex};
+
+        // Unmap until there are no more placeholders
+        while (UnmapOnePlaceholder(virtual_offset, length)) {
+        }
+    }
+
+    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {
+        DWORD new_flags{};
+        if (read && write) {
+            new_flags = PAGE_READWRITE;
+        } else if (read && !write) {
+            new_flags = PAGE_READONLY;
+        } else if (!read && !write) {
+            new_flags = PAGE_NOACCESS;
+        } else {
+            UNIMPLEMENTED_MSG("Protection flag combination read={} write={}", read, write);
+        }
+        const size_t virtual_end = virtual_offset + length;
+
+        std::lock_guard lock{placeholder_mutex};
+        auto [it, end] = placeholders.equal_range({virtual_offset, virtual_end});
+        while (it != end) {
+            const size_t offset = std::max(it->lower(), virtual_offset);
+            const size_t protect_length = std::min(it->upper(), virtual_end) - offset;
+            DWORD old_flags{};
+            if (!VirtualProtect(virtual_base + offset, protect_length, new_flags, &old_flags)) {
+                LOG_CRITICAL(HW_Memory, "Failed to change virtual memory protect rules");
+            }
+            ++it;
+        }
+    }
+
+    const size_t backing_size; ///< Size of the backing memory in bytes
+    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
+
+    u8* backing_base{};
+    u8* virtual_base{};
+
+private:
+    /// Release all resources in the object
+    void Release() {
+        if (!placeholders.empty()) {
+            for (const auto& placeholder : placeholders) {
+                if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder.lower(),
+                                          MEM_PRESERVE_PLACEHOLDER)) {
+                    LOG_CRITICAL(HW_Memory, "Failed to unmap virtual memory placeholder");
+                }
+            }
+            Coalesce(0, virtual_size);
+        }
+        if (virtual_base) {
+            if (!VirtualFree(virtual_base, 0, MEM_RELEASE)) {
+                LOG_CRITICAL(HW_Memory, "Failed to free virtual memory");
+            }
+        }
+        if (backing_base) {
+            if (!pfn_UnmapViewOfFile2(process, backing_base, MEM_PRESERVE_PLACEHOLDER)) {
+                LOG_CRITICAL(HW_Memory, "Failed to unmap backing memory placeholder");
+            }
+            if (!VirtualFreeEx(process, backing_base, 0, MEM_RELEASE)) {
+                LOG_CRITICAL(HW_Memory, "Failed to free backing memory");
+            }
+        }
+        if (!CloseHandle(backing_handle)) {
+            LOG_CRITICAL(HW_Memory, "Failed to free backing memory file handle");
+        }
+    }
+
+    /// Unmap one placeholder in the given range (partial unmaps are supported)
+    /// Return true when there are no more placeholders to unmap
+    bool UnmapOnePlaceholder(size_t virtual_offset, size_t length) {
+        const auto it = placeholders.find({virtual_offset, virtual_offset + length});
+        const auto begin = placeholders.begin();
+        const auto end = placeholders.end();
+        if (it == end) {
+            return false;
+        }
+        const size_t placeholder_begin = it->lower();
+        const size_t placeholder_end = it->upper();
+        const size_t unmap_begin = std::max(virtual_offset, placeholder_begin);
+        const size_t unmap_end = std::min(virtual_offset + length, placeholder_end);
+        ASSERT(unmap_begin >= placeholder_begin && unmap_begin < placeholder_end);
+        ASSERT(unmap_end <= placeholder_end && unmap_end > placeholder_begin);
+
+        const auto host_pointer_it = placeholder_host_pointers.find(placeholder_begin);
+        ASSERT(host_pointer_it != placeholder_host_pointers.end());
+        const size_t host_offset = host_pointer_it->second;
+
+        const bool split_left = unmap_begin > placeholder_begin;
+        const bool split_right = unmap_end < placeholder_end;
+
+        if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder_begin,
+                                  MEM_PRESERVE_PLACEHOLDER)) {
+            LOG_CRITICAL(HW_Memory, "Failed to unmap placeholder");
+        }
+        // If we have to remap memory regions due to partial unmaps, we are in a data race as
+        // Windows doesn't support remapping memory without unmapping first. Avoid adding any extra
+        // logic within the panic region described below.
+
+        // Panic region, we are in a data race right now
+        if (split_left || split_right) {
+            Split(unmap_begin, unmap_end - unmap_begin);
+        }
+        if (split_left) {
+            MapView(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
+        }
+        if (split_right) {
+            MapView(unmap_end, host_offset + unmap_end - placeholder_begin,
+                    placeholder_end - unmap_end);
+        }
+        // End panic region
+
+        size_t coalesce_begin = unmap_begin;
+        if (!split_left) {
+            // Try to coalesce pages to the left
+            coalesce_begin = it == begin ? 0 : std::prev(it)->upper();
+            if (coalesce_begin != placeholder_begin) {
+                Coalesce(coalesce_begin, unmap_end - coalesce_begin);
+            }
+        }
+        if (!split_right) {
+            // Try to coalesce pages to the right
+            const auto next = std::next(it);
+            const size_t next_begin = next == end ? virtual_size : next->lower();
+            if (placeholder_end != next_begin) {
+                // We can coalesce to the right
+                Coalesce(coalesce_begin, next_begin - coalesce_begin);
+            }
+        }
+        // Remove and reinsert placeholder trackers
+        UntrackPlaceholder(it);
+        if (split_left) {
+            TrackPlaceholder(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
+        }
+        if (split_right) {
+            TrackPlaceholder(unmap_end, host_offset + unmap_end - placeholder_begin,
+                             placeholder_end - unmap_end);
+        }
+        return true;
+    }
+
+    void MapView(size_t virtual_offset, size_t host_offset, size_t length) {
+        if (!pfn_MapViewOfFile3(backing_handle, process, virtual_base + virtual_offset, host_offset,
+                                length, MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0)) {
+            LOG_CRITICAL(HW_Memory, "Failed to map placeholder");
+        }
+    }
+
+    void Split(size_t virtual_offset, size_t length) {
+        if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length,
+                           MEM_RELEASE | MEM_PRESERVE_PLACEHOLDER)) {
+            LOG_CRITICAL(HW_Memory, "Failed to split placeholder");
+        }
+    }
+
+    void Coalesce(size_t virtual_offset, size_t length) {
+        if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length,
+                           MEM_RELEASE | MEM_COALESCE_PLACEHOLDERS)) {
+            LOG_CRITICAL(HW_Memory, "Failed to coalesce placeholders");
+        }
+    }
+
+    void TrackPlaceholder(size_t virtual_offset, size_t host_offset, size_t length) {
+        placeholders.insert({virtual_offset, virtual_offset + length});
+        placeholder_host_pointers.emplace(virtual_offset, host_offset);
+    }
+
+    void UntrackPlaceholder(boost::icl::separate_interval_set<size_t>::iterator it) {
+        placeholders.erase(it);
+        placeholder_host_pointers.erase(it->lower());
+    }
+
+    /// Return true when a given memory region is a "nieche" and the placeholders don't have to be
+    /// splitted.
+    bool IsNiechePlaceholder(size_t virtual_offset, size_t length) const {
+        const auto it = placeholders.upper_bound({virtual_offset, virtual_offset + length});
+        if (it != placeholders.end() && it->lower() == virtual_offset + length) {
+            const bool is_root = it == placeholders.begin() && virtual_offset == 0;
+            return is_root || std::prev(it)->upper() == virtual_offset;
+        }
+        return false;
+    }
+
+    HANDLE process{};        ///< Current process handle
+    HANDLE backing_handle{}; ///< File based backing memory
+
+    DynamicLibrary kernelbase_dll;
+    PFN_CreateFileMapping2 pfn_CreateFileMapping2{};
+    PFN_VirtualAlloc2 pfn_VirtualAlloc2{};
+    PFN_MapViewOfFile3 pfn_MapViewOfFile3{};
+    PFN_UnmapViewOfFile2 pfn_UnmapViewOfFile2{};
+
+    std::mutex placeholder_mutex;                                 ///< Mutex for placeholders
+    boost::icl::separate_interval_set<size_t> placeholders;       ///< Mapped placeholders
+    std::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
+};
+
+#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
+
+class HostMemory::Impl {
+public:
+    explicit Impl(size_t backing_size_, size_t virtual_size_)
+        : backing_size{backing_size_}, virtual_size{virtual_size_} {
+        bool good = false;
+        SCOPE_EXIT({
+            if (!good) {
+                Release();
+            }
+        });
+
+        // Backing memory initialization
+        fd = memfd_create("HostMemory", 0);
+        if (fd == -1) {
+            LOG_CRITICAL(HW_Memory, "memfd_create failed: {}", strerror(errno));
+            throw std::bad_alloc{};
+        }
+
+        // Defined to extend the file with zeros
+        int ret = ftruncate(fd, backing_size);
+        if (ret != 0) {
+            LOG_CRITICAL(HW_Memory, "ftruncate failed with {}, are you out-of-memory?",
+                         strerror(errno));
+            throw std::bad_alloc{};
+        }
+
+        backing_base = static_cast<u8*>(
+            mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+        if (backing_base == MAP_FAILED) {
+            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
+            throw std::bad_alloc{};
+        }
+
+        // Virtual memory initialization
+        virtual_base = static_cast<u8*>(
+            mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+        if (virtual_base == MAP_FAILED) {
+            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
+            throw std::bad_alloc{};
+        }
+
+        good = true;
+    }
+
+    ~Impl() {
+        Release();
+    }
+
+    void Map(size_t virtual_offset, size_t host_offset, size_t length) {
+
+        void* ret = mmap(virtual_base + virtual_offset, length, PROT_READ | PROT_WRITE,
+                         MAP_SHARED | MAP_FIXED, fd, host_offset);
+        ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
+    }
+
+    void Unmap(size_t virtual_offset, size_t length) {
+        // The method name is wrong. We're still talking about the virtual range.
+        // We don't want to unmap, we want to reserve this memory.
+
+        void* ret = mmap(virtual_base + virtual_offset, length, PROT_NONE,
+                         MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+        ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
+    }
+
+    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {
+        int flags = 0;
+        if (read) {
+            flags |= PROT_READ;
+        }
+        if (write) {
+            flags |= PROT_WRITE;
+        }
+        int ret = mprotect(virtual_base + virtual_offset, length, flags);
+        ASSERT_MSG(ret == 0, "mprotect failed: {}", strerror(errno));
+    }
+
+    const size_t backing_size; ///< Size of the backing memory in bytes
+    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
+
+    u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
+    u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
+
+private:
+    /// Release all resources in the object
+    void Release() {
+        if (virtual_base != MAP_FAILED) {
+            int ret = munmap(virtual_base, virtual_size);
+            ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
+        }
+
+        if (backing_base != MAP_FAILED) {
+            int ret = munmap(backing_base, backing_size);
+            ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
+        }
+
+        if (fd != -1) {
+            int ret = close(fd);
+            ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
+        }
+    }
+
+    int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
+};
+
+#else // ^^^ Linux ^^^ vvv Generic vvv
+
+class HostMemory::Impl {
+public:
+    explicit Impl(size_t /*backing_size */, size_t /* virtual_size */) {
+        // This is just a place holder.
+        // Please implement fastmem in a propper way on your platform.
+        throw std::bad_alloc{};
+    }
+
+    void Map(size_t virtual_offset, size_t host_offset, size_t length) {}
+
+    void Unmap(size_t virtual_offset, size_t length) {}
+
+    void Protect(size_t virtual_offset, size_t length, bool read, bool write) {}
+
+    u8* backing_base{nullptr};
+    u8* virtual_base{nullptr};
+};
+
+#endif // ^^^ Generic ^^^
+
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
+    : backing_size(backing_size_), virtual_size(virtual_size_) {
+    try {
+        // Try to allocate a fastmem arena.
+        // The implementation will fail with std::bad_alloc on errors.
+        impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment),
+                                                  AlignUp(virtual_size, PageAlignment) +
+                                                      3 * HugePageSize);
+        backing_base = impl->backing_base;
+        virtual_base = impl->virtual_base;
+
+        if (virtual_base) {
+            virtual_base += 2 * HugePageSize - 1;
+            virtual_base -= reinterpret_cast<size_t>(virtual_base) & (HugePageSize - 1);
+            virtual_base_offset = virtual_base - impl->virtual_base;
+        }
+
+    } catch (const std::bad_alloc&) {
+        LOG_CRITICAL(HW_Memory,
+                     "Fastmem unavailable, falling back to VirtualBuffer for memory allocation");
+        fallback_buffer = std::make_unique<Common::VirtualBuffer<u8>>(backing_size);
+        backing_base = fallback_buffer->data();
+        virtual_base = nullptr;
+    }
+}
+
+HostMemory::~HostMemory() = default;
+
+HostMemory::HostMemory(HostMemory&&) noexcept = default;
+
+HostMemory& HostMemory::operator=(HostMemory&&) noexcept = default;
+
+void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length) {
+    ASSERT(virtual_offset % PageAlignment == 0);
+    ASSERT(host_offset % PageAlignment == 0);
+    ASSERT(length % PageAlignment == 0);
+    ASSERT(virtual_offset + length <= virtual_size);
+    ASSERT(host_offset + length <= backing_size);
+    if (length == 0 || !virtual_base || !impl) {
+        return;
+    }
+    impl->Map(virtual_offset + virtual_base_offset, host_offset, length);
+}
+
+void HostMemory::Unmap(size_t virtual_offset, size_t length) {
+    ASSERT(virtual_offset % PageAlignment == 0);
+    ASSERT(length % PageAlignment == 0);
+    ASSERT(virtual_offset + length <= virtual_size);
+    if (length == 0 || !virtual_base || !impl) {
+        return;
+    }
+    impl->Unmap(virtual_offset + virtual_base_offset, length);
+}
+
+void HostMemory::Protect(size_t virtual_offset, size_t length, bool read, bool write) {
+    ASSERT(virtual_offset % PageAlignment == 0);
+    ASSERT(length % PageAlignment == 0);
+    ASSERT(virtual_offset + length <= virtual_size);
+    if (length == 0 || !virtual_base || !impl) {
+        return;
+    }
+    impl->Protect(virtual_offset + virtual_base_offset, length, read, write);
+}
+
+} // namespace Common

src/common/host_memory.h

@@ -0,0 +1,70 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include "common/common_types.h"
+#include "common/virtual_buffer.h"
+
+namespace Common {
+
+/**
+ * A low level linear memory buffer, which supports multiple mappings
+ * Its purpose is to rebuild a given sparse memory layout, including mirrors.
+ */
+class HostMemory {
+public:
+    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
+    ~HostMemory();
+
+    /**
+     * Copy constructors. They shall return a copy of the buffer without the mappings.
+     * TODO: Implement them with COW if needed.
+     */
+    HostMemory(const HostMemory& other) = delete;
+    HostMemory& operator=(const HostMemory& other) = delete;
+
+    /**
+     * Move constructors. They will move the buffer and the mappings to the new object.
+     */
+    HostMemory(HostMemory&& other) noexcept;
+    HostMemory& operator=(HostMemory&& other) noexcept;
+
+    void Map(size_t virtual_offset, size_t host_offset, size_t length);
+
+    void Unmap(size_t virtual_offset, size_t length);
+
+    void Protect(size_t virtual_offset, size_t length, bool read, bool write);
+
+    [[nodiscard]] u8* BackingBasePointer() noexcept {
+        return backing_base;
+    }
+    [[nodiscard]] const u8* BackingBasePointer() const noexcept {
+        return backing_base;
+    }
+
+    [[nodiscard]] u8* VirtualBasePointer() noexcept {
+        return virtual_base;
+    }
+    [[nodiscard]] const u8* VirtualBasePointer() const noexcept {
+        return virtual_base;
+    }
+
+private:
+    size_t backing_size{};
+    size_t virtual_size{};
+
+    // Low level handler for the platform dependent memory routines
+    class Impl;
+    std::unique_ptr<Impl> impl;
+    u8* backing_base{};
+    u8* virtual_base{};
+    size_t virtual_base_offset{};
+
+    // Fallback if fastmem is not supported on this platform
+    std::unique_ptr<Common::VirtualBuffer<u8>> fallback_buffer;
+};
+
+} // namespace Common

src/common/logging/backend.cpp

@@ -11,13 +11,14 @@
 #include <mutex>
 #include <thread>
 #include <vector>
+
 #ifdef _WIN32
-#include <share.h>   // For _SH_DENYWR
 #include <windows.h> // For OutputDebugStringW
-#else
-#define _SH_DENYWR 0
 #endif
+
 #include "common/assert.h"
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
 #include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
@@ -140,36 +141,40 @@ private:
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 
+ConsoleBackend::~ConsoleBackend() = default;
+
 void ConsoleBackend::Write(const Entry& entry) {
     PrintMessage(entry);
 }
 
+ColorConsoleBackend::~ColorConsoleBackend() = default;
+
 void ColorConsoleBackend::Write(const Entry& entry) {
     PrintColoredMessage(entry);
 }
 
-FileBackend::FileBackend(const std::string& filename) {
-    const auto old_filename = filename + ".old.txt";
+FileBackend::FileBackend(const std::filesystem::path& filename) {
+    auto old_filename = filename;
+    old_filename += ".old.txt";
 
-    if (FS::Exists(old_filename)) {
-        FS::Delete(old_filename);
-    }
-    if (FS::Exists(filename)) {
-        FS::Rename(filename, old_filename);
-    }
+    // Existence checks are done within the functions themselves.
+    // We don't particularly care if these succeed or not.
+    void(FS::RemoveFile(old_filename));
+    void(FS::RenameFile(filename, old_filename));
 
-    // _SH_DENYWR allows read only access to the file for other programs.
-    // It is #defined to 0 on other platforms
-    file = FS::IOFile(filename, "w", _SH_DENYWR);
+    file =
+        std::make_unique<FS::IOFile>(filename, FS::FileAccessMode::Write, FS::FileType::TextFile);
 }
 
+FileBackend::~FileBackend() = default;
+
 void FileBackend::Write(const Entry& entry) {
     // prevent logs from going over the maximum size (in case its spamming and the user doesn't
     // know)
     constexpr std::size_t MAX_BYTES_WRITTEN = 100 * 1024 * 1024;
     constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1024 * 1024 * 1024;
 
-    if (!file.IsOpen()) {
+    if (!file->IsOpen()) {
         return;
     }
 
@@ -179,147 +184,20 @@ void FileBackend::Write(const Entry& entry) {
         return;
     }
 
-    bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
+    bytes_written += file->WriteString(FormatLogMessage(entry).append(1, '\n'));
     if (entry.log_level >= Level::Error) {
-        file.Flush();
+        void(file->Flush());
     }
 }
 
+DebuggerBackend::~DebuggerBackend() = default;
+
 void DebuggerBackend::Write(const Entry& entry) {
 #ifdef _WIN32
     ::OutputDebugStringW(UTF8ToUTF16W(FormatLogMessage(entry).append(1, '\n')).c_str());
 #endif
 }
 
-/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
-#define ALL_LOG_CLASSES()                                                                          \
-    CLS(Log)                                                                                       \
-    CLS(Common)                                                                                    \
-    SUB(Common, Filesystem)                                                                        \
-    SUB(Common, Memory)                                                                            \
-    CLS(Core)                                                                                      \
-    SUB(Core, ARM)                                                                                 \
-    SUB(Core, Timing)                                                                              \
-    CLS(Config)                                                                                    \
-    CLS(Debug)                                                                                     \
-    SUB(Debug, Emulated)                                                                           \
-    SUB(Debug, GPU)                                                                                \
-    SUB(Debug, Breakpoint)                                                                         \
-    SUB(Debug, GDBStub)                                                                            \
-    CLS(Kernel)                                                                                    \
-    SUB(Kernel, SVC)                                                                               \
-    CLS(Service)                                                                                   \
-    SUB(Service, ACC)                                                                              \
-    SUB(Service, Audio)                                                                            \
-    SUB(Service, AM)                                                                               \
-    SUB(Service, AOC)                                                                              \
-    SUB(Service, APM)                                                                              \
-    SUB(Service, ARP)                                                                              \
-    SUB(Service, BCAT)                                                                             \
-    SUB(Service, BPC)                                                                              \
-    SUB(Service, BGTC)                                                                             \
-    SUB(Service, BTDRV)                                                                            \
-    SUB(Service, BTM)                                                                              \
-    SUB(Service, Capture)                                                                          \
-    SUB(Service, ERPT)                                                                             \
-    SUB(Service, ETicket)                                                                          \
-    SUB(Service, EUPLD)                                                                            \
-    SUB(Service, Fatal)                                                                            \
-    SUB(Service, FGM)                                                                              \
-    SUB(Service, Friend)                                                                           \
-    SUB(Service, FS)                                                                               \
-    SUB(Service, GRC)                                                                              \
-    SUB(Service, HID)                                                                              \
-    SUB(Service, IRS)                                                                              \
-    SUB(Service, LBL)                                                                              \
-    SUB(Service, LDN)                                                                              \
-    SUB(Service, LDR)                                                                              \
-    SUB(Service, LM)                                                                               \
-    SUB(Service, Migration)                                                                        \
-    SUB(Service, Mii)                                                                              \
-    SUB(Service, MM)                                                                               \
-    SUB(Service, NCM)                                                                              \
-    SUB(Service, NFC)                                                                              \
-    SUB(Service, NFP)                                                                              \
-    SUB(Service, NIFM)                                                                             \
-    SUB(Service, NIM)                                                                              \
-    SUB(Service, NPNS)                                                                             \
-    SUB(Service, NS)                                                                               \
-    SUB(Service, NVDRV)                                                                            \
-    SUB(Service, OLSC)                                                                             \
-    SUB(Service, PCIE)                                                                             \
-    SUB(Service, PCTL)                                                                             \
-    SUB(Service, PCV)                                                                              \
-    SUB(Service, PM)                                                                               \
-    SUB(Service, PREPO)                                                                            \
-    SUB(Service, PSC)                                                                              \
-    SUB(Service, PSM)                                                                              \
-    SUB(Service, SET)                                                                              \
-    SUB(Service, SM)                                                                               \
-    SUB(Service, SPL)                                                                              \
-    SUB(Service, SSL)                                                                              \
-    SUB(Service, TCAP)                                                                             \
-    SUB(Service, Time)                                                                             \
-    SUB(Service, USB)                                                                              \
-    SUB(Service, VI)                                                                               \
-    SUB(Service, WLAN)                                                                             \
-    CLS(HW)                                                                                        \
-    SUB(HW, Memory)                                                                                \
-    SUB(HW, LCD)                                                                                   \
-    SUB(HW, GPU)                                                                                   \
-    SUB(HW, AES)                                                                                   \
-    CLS(IPC)                                                                                       \
-    CLS(Frontend)                                                                                  \
-    CLS(Render)                                                                                    \
-    SUB(Render, Software)                                                                          \
-    SUB(Render, OpenGL)                                                                            \
-    SUB(Render, Vulkan)                                                                            \
-    CLS(Audio)                                                                                     \
-    SUB(Audio, DSP)                                                                                \
-    SUB(Audio, Sink)                                                                               \
-    CLS(Input)                                                                                     \
-    CLS(Network)                                                                                   \
-    CLS(Loader)                                                                                    \
-    CLS(CheatEngine)                                                                               \
-    CLS(Crypto)                                                                                    \
-    CLS(WebService)
-
-// GetClassName is a macro defined by Windows.h, grrr...
-const char* GetLogClassName(Class log_class) {
-    switch (log_class) {
-#define CLS(x)                                                                                     \
-    case Class::x:                                                                                 \
-        return #x;
-#define SUB(x, y)                                                                                  \
-    case Class::x##_##y:                                                                           \
-        return #x "." #y;
-        ALL_LOG_CLASSES()
-#undef CLS
-#undef SUB
-    case Class::Count:
-        break;
-    }
-    return "Invalid";
-}
-
-const char* GetLevelName(Level log_level) {
-#define LVL(x)                                                                                     \
-    case Level::x:                                                                                 \
-        return #x
-    switch (log_level) {
-        LVL(Trace);
-        LVL(Debug);
-        LVL(Info);
-        LVL(Warning);
-        LVL(Error);
-        LVL(Critical);
-    case Level::Count:
-        break;
-    }
-#undef LVL
-    return "Invalid";
-}
-
 void SetGlobalFilter(const Filter& filter) {
     Impl::Instance().SetGlobalFilter(filter);
 }

src/common/logging/backend.h

@@ -1,35 +1,24 @@
 // Copyright 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
+
 #pragma once
 
-#include <chrono>
+#include <filesystem>
 #include <memory>
 #include <string>
 #include <string_view>
-#include "common/file_util.h"
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
 
+namespace Common::FS {
+class IOFile;
+}
+
 namespace Common::Log {
 
 class Filter;
 
-/**
- * A log entry. Log entries are store in a structured format to permit more varied output
- * formatting on different frontends, as well as facilitating filtering and aggregation.
- */
-struct Entry {
-    std::chrono::microseconds timestamp;
-    Class log_class{};
-    Level log_level{};
-    const char* filename = nullptr;
-    unsigned int line_num = 0;
-    std::string function;
-    std::string message;
-    bool final_entry = false;
-};
-
 /**
  * Interface for logging backends. As loggers can be created and removed at runtime, this can be
  * used by a frontend for adding a custom logging backend as needed
@@ -37,6 +26,7 @@ struct Entry {
 class Backend {
 public:
     virtual ~Backend() = default;
+
     virtual void SetFilter(const Filter& new_filter) {
         filter = new_filter;
     }
@@ -52,6 +42,8 @@ private:
  */
 class ConsoleBackend : public Backend {
 public:
+    ~ConsoleBackend() override;
+
     static const char* Name() {
         return "console";
     }
@@ -66,6 +58,8 @@ public:
  */
 class ColorConsoleBackend : public Backend {
 public:
+    ~ColorConsoleBackend() override;
+
     static const char* Name() {
         return "color_console";
     }
@@ -81,7 +75,8 @@ public:
  */
 class FileBackend : public Backend {
 public:
-    explicit FileBackend(const std::string& filename);
+    explicit FileBackend(const std::filesystem::path& filename);
+    ~FileBackend() override;
 
     static const char* Name() {
         return "file";
@@ -94,7 +89,7 @@ public:
     void Write(const Entry& entry) override;
 
 private:
-    FS::IOFile file;
+    std::unique_ptr<FS::IOFile> file;
     std::size_t bytes_written = 0;
 };
 
@@ -103,6 +98,8 @@ private:
  */
 class DebuggerBackend : public Backend {
 public:
+    ~DebuggerBackend() override;
+
     static const char* Name() {
         return "debugger";
     }
@@ -118,17 +115,6 @@ void RemoveBackend(std::string_view backend_name);
 
 Backend* GetBackend(std::string_view backend_name);
 
-/**
- * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
- * instead of underscores as in the enumeration.
- */
-const char* GetLogClassName(Class log_class);
-
-/**
- * Returns the name of the passed log level as a C-string.
- */
-const char* GetLevelName(Level log_level);
-
 /**
  * The global filter will prevent any messages from even being processed if they are filtered. Each
  * backend can have a filter, but if the level is lower than the global filter, the backend will

src/common/logging/filter.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include "common/logging/backend.h"
 #include "common/logging/filter.h"
 #include "common/string_util.h"
 
@@ -22,7 +21,7 @@ Level GetLevelByName(const It begin, const It end) {
 
 template <typename It>
 Class GetClassByName(const It begin, const It end) {
-    for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
+    for (u8 i = 0; i < static_cast<u8>(Class::Count); ++i) {
         const char* level_name = GetLogClassName(static_cast<Class>(i));
         if (Common::ComparePartialString(begin, end, level_name)) {
             return static_cast<Class>(i);
@@ -62,6 +61,135 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
 }
 } // Anonymous namespace
 
+/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
+#define ALL_LOG_CLASSES()                                                                          \
+    CLS(Log)                                                                                       \
+    CLS(Common)                                                                                    \
+    SUB(Common, Filesystem)                                                                        \
+    SUB(Common, Memory)                                                                            \
+    CLS(Core)                                                                                      \
+    SUB(Core, ARM)                                                                                 \
+    SUB(Core, Timing)                                                                              \
+    CLS(Config)                                                                                    \
+    CLS(Debug)                                                                                     \
+    SUB(Debug, Emulated)                                                                           \
+    SUB(Debug, GPU)                                                                                \
+    SUB(Debug, Breakpoint)                                                                         \
+    SUB(Debug, GDBStub)                                                                            \
+    CLS(Kernel)                                                                                    \
+    SUB(Kernel, SVC)                                                                               \
+    CLS(Service)                                                                                   \
+    SUB(Service, ACC)                                                                              \
+    SUB(Service, Audio)                                                                            \
+    SUB(Service, AM)                                                                               \
+    SUB(Service, AOC)                                                                              \
+    SUB(Service, APM)                                                                              \
+    SUB(Service, ARP)                                                                              \
+    SUB(Service, BCAT)                                                                             \
+    SUB(Service, BPC)                                                                              \
+    SUB(Service, BGTC)                                                                             \
+    SUB(Service, BTDRV)                                                                            \
+    SUB(Service, BTM)                                                                              \
+    SUB(Service, Capture)                                                                          \
+    SUB(Service, ERPT)                                                                             \
+    SUB(Service, ETicket)                                                                          \
+    SUB(Service, EUPLD)                                                                            \
+    SUB(Service, Fatal)                                                                            \
+    SUB(Service, FGM)                                                                              \
+    SUB(Service, Friend)                                                                           \
+    SUB(Service, FS)                                                                               \
+    SUB(Service, GRC)                                                                              \
+    SUB(Service, HID)                                                                              \
+    SUB(Service, IRS)                                                                              \
+    SUB(Service, LBL)                                                                              \
+    SUB(Service, LDN)                                                                              \
+    SUB(Service, LDR)                                                                              \
+    SUB(Service, LM)                                                                               \
+    SUB(Service, Migration)                                                                        \
+    SUB(Service, Mii)                                                                              \
+    SUB(Service, MM)                                                                               \
+    SUB(Service, NCM)                                                                              \
+    SUB(Service, NFC)                                                                              \
+    SUB(Service, NFP)                                                                              \
+    SUB(Service, NIFM)                                                                             \
+    SUB(Service, NIM)                                                                              \
+    SUB(Service, NPNS)                                                                             \
+    SUB(Service, NS)                                                                               \
+    SUB(Service, NVDRV)                                                                            \
+    SUB(Service, OLSC)                                                                             \
+    SUB(Service, PCIE)                                                                             \
+    SUB(Service, PCTL)                                                                             \
+    SUB(Service, PCV)                                                                              \
+    SUB(Service, PM)                                                                               \
+    SUB(Service, PREPO)                                                                            \
+    SUB(Service, PSC)                                                                              \
+    SUB(Service, PSM)                                                                              \
+    SUB(Service, SET)                                                                              \
+    SUB(Service, SM)                                                                               \
+    SUB(Service, SPL)                                                                              \
+    SUB(Service, SSL)                                                                              \
+    SUB(Service, TCAP)                                                                             \
+    SUB(Service, Time)                                                                             \
+    SUB(Service, USB)                                                                              \
+    SUB(Service, VI)                                                                               \
+    SUB(Service, WLAN)                                                                             \
+    CLS(HW)                                                                                        \
+    SUB(HW, Memory)                                                                                \
+    SUB(HW, LCD)                                                                                   \
+    SUB(HW, GPU)                                                                                   \
+    SUB(HW, AES)                                                                                   \
+    CLS(IPC)                                                                                       \
+    CLS(Frontend)                                                                                  \
+    CLS(Render)                                                                                    \
+    SUB(Render, Software)                                                                          \
+    SUB(Render, OpenGL)                                                                            \
+    SUB(Render, Vulkan)                                                                            \
+    CLS(Audio)                                                                                     \
+    SUB(Audio, DSP)                                                                                \
+    SUB(Audio, Sink)                                                                               \
+    CLS(Input)                                                                                     \
+    CLS(Network)                                                                                   \
+    CLS(Loader)                                                                                    \
+    CLS(CheatEngine)                                                                               \
+    CLS(Crypto)                                                                                    \
+    CLS(WebService)
+
+// GetClassName is a macro defined by Windows.h, grrr...
+const char* GetLogClassName(Class log_class) {
+    switch (log_class) {
+#define CLS(x)                                                                                     \
+    case Class::x:                                                                                 \
+        return #x;
+#define SUB(x, y)                                                                                  \
+    case Class::x##_##y:                                                                           \
+        return #x "." #y;
+        ALL_LOG_CLASSES()
+#undef CLS
+#undef SUB
+    case Class::Count:
+        break;
+    }
+    return "Invalid";
+}
+
+const char* GetLevelName(Level log_level) {
+#define LVL(x)                                                                                     \
+    case Level::x:                                                                                 \
+        return #x
+    switch (log_level) {
+        LVL(Trace);
+        LVL(Debug);
+        LVL(Info);
+        LVL(Warning);
+        LVL(Error);
+        LVL(Critical);
+    case Level::Count:
+        break;
+    }
+#undef LVL
+    return "Invalid";
+}
+
 Filter::Filter(Level default_level) {
     ResetAll(default_level);
 }

src/common/logging/filter.h

@@ -5,12 +5,24 @@
 #pragma once
 
 #include <array>
+#include <chrono>
 #include <cstddef>
 #include <string_view>
 #include "common/logging/log.h"
 
 namespace Common::Log {
 
+/**
+ * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
+ * instead of underscores as in the enumeration.
+ */
+const char* GetLogClassName(Class log_class);
+
+/**
+ * Returns the name of the passed log level as a C-string.
+ */
+const char* GetLevelName(Level log_level);
+
 /**
  * Implements a log message filter which allows different log classes to have different minimum
  * severity levels. The filter can be changed at runtime and can be parsed from a string to allow

src/common/logging/log.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <fmt/format.h>
-#include "common/common_types.h"
+#include "common/logging/types.h"
 
 namespace Common::Log {
 
@@ -18,124 +18,6 @@ constexpr const char* TrimSourcePath(std::string_view source) {
     return source.data() + idx;
 }
 
-/// Specifies the severity or level of detail of the log message.
-enum class Level : u8 {
-    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
-              ///< pollute logs.
-    Debug,    ///< Less detailed debugging information.
-    Info,     ///< Status information from important points during execution.
-    Warning,  ///< Minor or potential problems found during execution of a task.
-    Error,    ///< Major problems found during execution of a task that prevent it from being
-              ///< completed.
-    Critical, ///< Major problems during execution that threaten the stability of the entire
-              ///< application.
-
-    Count ///< Total number of logging levels
-};
-
-typedef u8 ClassType;
-
-/**
- * Specifies the sub-system that generated the log message.
- *
- * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
- * backend.cpp.
- */
-enum class Class : ClassType {
-    Log,               ///< Messages about the log system itself
-    Common,            ///< Library routines
-    Common_Filesystem, ///< Filesystem interface library
-    Common_Memory,     ///< Memory mapping and management functions
-    Core,              ///< LLE emulation core
-    Core_ARM,          ///< ARM CPU core
-    Core_Timing,       ///< CoreTiming functions
-    Config,            ///< Emulator configuration (including commandline)
-    Debug,             ///< Debugging tools
-    Debug_Emulated,    ///< Debug messages from the emulated programs
-    Debug_GPU,         ///< GPU debugging tools
-    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
-    Debug_GDBStub,     ///< GDB Stub
-    Kernel,            ///< The HLE implementation of the CTR kernel
-    Kernel_SVC,        ///< Kernel system calls
-    Service,           ///< HLE implementation of system services. Each major service
-                       ///< should have its own subclass.
-    Service_ACC,       ///< The ACC (Accounts) service
-    Service_AM,        ///< The AM (Applet manager) service
-    Service_AOC,       ///< The AOC (AddOn Content) service
-    Service_APM,       ///< The APM (Performance) service
-    Service_ARP,       ///< The ARP service
-    Service_Audio,     ///< The Audio (Audio control) service
-    Service_BCAT,      ///< The BCAT service
-    Service_BGTC,      ///< The BGTC (Background Task Controller) service
-    Service_BPC,       ///< The BPC service
-    Service_BTDRV,     ///< The Bluetooth driver service
-    Service_BTM,       ///< The BTM service
-    Service_Capture,   ///< The capture service
-    Service_ERPT,      ///< The error reporting service
-    Service_ETicket,   ///< The ETicket service
-    Service_EUPLD,     ///< The error upload service
-    Service_Fatal,     ///< The Fatal service
-    Service_FGM,       ///< The FGM service
-    Service_Friend,    ///< The friend service
-    Service_FS,        ///< The FS (Filesystem) service
-    Service_GRC,       ///< The game recording service
-    Service_HID,       ///< The HID (Human interface device) service
-    Service_IRS,       ///< The IRS service
-    Service_LBL,       ///< The LBL (LCD backlight) service
-    Service_LDN,       ///< The LDN (Local domain network) service
-    Service_LDR,       ///< The loader service
-    Service_LM,        ///< The LM (Logger) service
-    Service_Migration, ///< The migration service
-    Service_Mii,       ///< The Mii service
-    Service_MM,        ///< The MM (Multimedia) service
-    Service_NCM,       ///< The NCM service
-    Service_NFC,       ///< The NFC (Near-field communication) service
-    Service_NFP,       ///< The NFP service
-    Service_NIFM,      ///< The NIFM (Network interface) service
-    Service_NIM,       ///< The NIM service
-    Service_NPNS,      ///< The NPNS service
-    Service_NS,        ///< The NS services
-    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
-    Service_OLSC,      ///< The OLSC service
-    Service_PCIE,      ///< The PCIe service
-    Service_PCTL,      ///< The PCTL (Parental control) service
-    Service_PCV,       ///< The PCV service
-    Service_PM,        ///< The PM service
-    Service_PREPO,     ///< The PREPO (Play report) service
-    Service_PSC,       ///< The PSC service
-    Service_PSM,       ///< The PSM service
-    Service_SET,       ///< The SET (Settings) service
-    Service_SM,        ///< The SM (Service manager) service
-    Service_SPL,       ///< The SPL service
-    Service_SSL,       ///< The SSL service
-    Service_TCAP,      ///< The TCAP service.
-    Service_Time,      ///< The time service
-    Service_USB,       ///< The USB (Universal Serial Bus) service
-    Service_VI,        ///< The VI (Video interface) service
-    Service_WLAN,      ///< The WLAN (Wireless local area network) service
-    HW,                ///< Low-level hardware emulation
-    HW_Memory,         ///< Memory-map and address translation
-    HW_LCD,            ///< LCD register emulation
-    HW_GPU,            ///< GPU control emulation
-    HW_AES,            ///< AES engine emulation
-    IPC,               ///< IPC interface
-    Frontend,          ///< Emulator UI
-    Render,            ///< Emulator video output and hardware acceleration
-    Render_Software,   ///< Software renderer backend
-    Render_OpenGL,     ///< OpenGL backend
-    Render_Vulkan,     ///< Vulkan backend
-    Audio,             ///< Audio emulation
-    Audio_DSP,         ///< The HLE implementation of the DSP
-    Audio_Sink,        ///< Emulator audio output backend
-    Loader,            ///< ROM loader
-    CheatEngine,       ///< Memory manipulation and engine VM functions
-    Crypto,            ///< Cryptographic engine/functions
-    Input,             ///< Input emulation
-    Network,           ///< Network emulation
-    WebService,        ///< Interface to yuzu Web Services
-    Count              ///< Total number of logging classes
-};
-
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                        unsigned int line_num, const char* function, const char* format,

src/common/logging/text_formatter.cpp

@@ -11,7 +11,7 @@
 
 #include "common/assert.h"
 #include "common/common_funcs.h"
-#include "common/logging/backend.h"
+#include "common/logging/filter.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
 #include "common/string_util.h"

src/common/logging/types.h

@@ -0,0 +1,142 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <chrono>
+
+#include "common/common_types.h"
+
+namespace Common::Log {
+
+/// Specifies the severity or level of detail of the log message.
+enum class Level : u8 {
+    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
+              ///< pollute logs.
+    Debug,    ///< Less detailed debugging information.
+    Info,     ///< Status information from important points during execution.
+    Warning,  ///< Minor or potential problems found during execution of a task.
+    Error,    ///< Major problems found during execution of a task that prevent it from being
+              ///< completed.
+    Critical, ///< Major problems during execution that threaten the stability of the entire
+              ///< application.
+
+    Count ///< Total number of logging levels
+};
+
+/**
+ * Specifies the sub-system that generated the log message.
+ *
+ * @note If you add a new entry here, also add a corresponding one to `ALL_LOG_CLASSES` in
+ * filter.cpp.
+ */
+enum class Class : u8 {
+    Log,               ///< Messages about the log system itself
+    Common,            ///< Library routines
+    Common_Filesystem, ///< Filesystem interface library
+    Common_Memory,     ///< Memory mapping and management functions
+    Core,              ///< LLE emulation core
+    Core_ARM,          ///< ARM CPU core
+    Core_Timing,       ///< CoreTiming functions
+    Config,            ///< Emulator configuration (including commandline)
+    Debug,             ///< Debugging tools
+    Debug_Emulated,    ///< Debug messages from the emulated programs
+    Debug_GPU,         ///< GPU debugging tools
+    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
+    Debug_GDBStub,     ///< GDB Stub
+    Kernel,            ///< The HLE implementation of the CTR kernel
+    Kernel_SVC,        ///< Kernel system calls
+    Service,           ///< HLE implementation of system services. Each major service
+                       ///< should have its own subclass.
+    Service_ACC,       ///< The ACC (Accounts) service
+    Service_AM,        ///< The AM (Applet manager) service
+    Service_AOC,       ///< The AOC (AddOn Content) service
+    Service_APM,       ///< The APM (Performance) service
+    Service_ARP,       ///< The ARP service
+    Service_Audio,     ///< The Audio (Audio control) service
+    Service_BCAT,      ///< The BCAT service
+    Service_BGTC,      ///< The BGTC (Background Task Controller) service
+    Service_BPC,       ///< The BPC service
+    Service_BTDRV,     ///< The Bluetooth driver service
+    Service_BTM,       ///< The BTM service
+    Service_Capture,   ///< The capture service
+    Service_ERPT,      ///< The error reporting service
+    Service_ETicket,   ///< The ETicket service
+    Service_EUPLD,     ///< The error upload service
+    Service_Fatal,     ///< The Fatal service
+    Service_FGM,       ///< The FGM service
+    Service_Friend,    ///< The friend service
+    Service_FS,        ///< The FS (Filesystem) service
+    Service_GRC,       ///< The game recording service
+    Service_HID,       ///< The HID (Human interface device) service
+    Service_IRS,       ///< The IRS service
+    Service_LBL,       ///< The LBL (LCD backlight) service
+    Service_LDN,       ///< The LDN (Local domain network) service
+    Service_LDR,       ///< The loader service
+    Service_LM,        ///< The LM (Logger) service
+    Service_Migration, ///< The migration service
+    Service_Mii,       ///< The Mii service
+    Service_MM,        ///< The MM (Multimedia) service
+    Service_NCM,       ///< The NCM service
+    Service_NFC,       ///< The NFC (Near-field communication) service
+    Service_NFP,       ///< The NFP service
+    Service_NIFM,      ///< The NIFM (Network interface) service
+    Service_NIM,       ///< The NIM service
+    Service_NPNS,      ///< The NPNS service
+    Service_NS,        ///< The NS services
+    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
+    Service_OLSC,      ///< The OLSC service
+    Service_PCIE,      ///< The PCIe service
+    Service_PCTL,      ///< The PCTL (Parental control) service
+    Service_PCV,       ///< The PCV service
+    Service_PM,        ///< The PM service
+    Service_PREPO,     ///< The PREPO (Play report) service
+    Service_PSC,       ///< The PSC service
+    Service_PSM,       ///< The PSM service
+    Service_SET,       ///< The SET (Settings) service
+    Service_SM,        ///< The SM (Service manager) service
+    Service_SPL,       ///< The SPL service
+    Service_SSL,       ///< The SSL service
+    Service_TCAP,      ///< The TCAP service.
+    Service_Time,      ///< The time service
+    Service_USB,       ///< The USB (Universal Serial Bus) service
+    Service_VI,        ///< The VI (Video interface) service
+    Service_WLAN,      ///< The WLAN (Wireless local area network) service
+    HW,                ///< Low-level hardware emulation
+    HW_Memory,         ///< Memory-map and address translation
+    HW_LCD,            ///< LCD register emulation
+    HW_GPU,            ///< GPU control emulation
+    HW_AES,            ///< AES engine emulation
+    IPC,               ///< IPC interface
+    Frontend,          ///< Emulator UI
+    Render,            ///< Emulator video output and hardware acceleration
+    Render_Software,   ///< Software renderer backend
+    Render_OpenGL,     ///< OpenGL backend
+    Render_Vulkan,     ///< Vulkan backend
+    Audio,             ///< Audio emulation
+    Audio_DSP,         ///< The HLE implementation of the DSP
+    Audio_Sink,        ///< Emulator audio output backend
+    Loader,            ///< ROM loader
+    CheatEngine,       ///< Memory manipulation and engine VM functions
+    Crypto,            ///< Cryptographic engine/functions
+    Input,             ///< Input emulation
+    Network,           ///< Network emulation
+    WebService,        ///< Interface to yuzu Web Services
+    Count              ///< Total number of logging classes
+};
+
+/**
+ * A log entry. Log entries are store in a structured format to permit more varied output
+ * formatting on different frontends, as well as facilitating filtering and aggregation.
+ */
+struct Entry {
+    std::chrono::microseconds timestamp;
+    Class log_class{};
+    Level log_level{};
+    const char* filename = nullptr;
+    unsigned int line_num = 0;
+    std::string function;
+    std::string message;
+    bool final_entry = false;
+};
+
+} // namespace Common::Log

src/common/nvidia_flags.cpp

@@ -2,24 +2,30 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <filesystem>
-#include <stdlib.h>
+#include <cstdlib>
 
 #include <fmt/format.h>
 
-#include "common/file_util.h"
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
 #include "common/nvidia_flags.h"
 
 namespace Common {
 
 void ConfigureNvidiaEnvironmentFlags() {
 #ifdef _WIN32
-    const std::string shader_path = Common::FS::SanitizePath(
-        fmt::format("{}/nvidia/", Common::FS::GetUserPath(Common::FS::UserPath::ShaderDir)));
-    const std::string windows_path =
-        Common::FS::SanitizePath(shader_path, Common::FS::DirectorySeparator::BackwardSlash);
-    void(Common::FS::CreateFullPath(shader_path + '/'));
-    void(_putenv(fmt::format("__GL_SHADER_DISK_CACHE_PATH={}", windows_path).c_str()));
+    const auto nvidia_shader_dir =
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::ShaderDir) / "nvidia";
+
+    if (!Common::FS::CreateDirs(nvidia_shader_dir)) {
+        return;
+    }
+
+    const auto windows_path_string =
+        Common::FS::PathToUTF8String(nvidia_shader_dir.lexically_normal());
+
+    void(_putenv(fmt::format("__GL_SHADER_DISK_CACHE_PATH={}", windows_path_string).c_str()));
     void(_putenv("__GL_SHADER_DISK_CACHE_SKIP_CLEANUP=1"));
 #endif
 }

src/common/page_table.cpp

@@ -14,6 +14,7 @@ void PageTable::Resize(size_t address_space_width_in_bits, size_t page_size_in_b
     const size_t num_page_table_entries{1ULL << (address_space_width_in_bits - page_size_in_bits)};
     pointers.resize(num_page_table_entries);
     backing_addr.resize(num_page_table_entries);
+    current_address_space_width_in_bits = address_space_width_in_bits;
 }
 
 } // namespace Common

src/common/page_table.h

@@ -98,6 +98,10 @@ struct PageTable {
      */
     void Resize(size_t address_space_width_in_bits, size_t page_size_in_bits);
 
+    size_t GetAddressSpaceBits() const {
+        return current_address_space_width_in_bits;
+    }
+
     /**
      * Vector of memory pointers backing each page. An entry can only be non-null if the
      * corresponding attribute element is of type `Memory`.
@@ -105,6 +109,10 @@ struct PageTable {
     VirtualBuffer<PageInfo> pointers;
 
     VirtualBuffer<u64> backing_addr;
+
+    size_t current_address_space_width_in_bits;
+
+    u8* fastmem_arena;
 };
 
 } // namespace Common

src/common/point.h

@@ -0,0 +1,57 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <type_traits>
+
+namespace Common {
+
+// Represents a point within a 2D space.
+template <typename T>
+struct Point {
+    static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type!");
+
+    T x{};
+    T y{};
+
+#define ARITHMETIC_OP(op, compound_op)                                                             \
+    friend constexpr Point operator op(const Point& lhs, const Point& rhs) noexcept {              \
+        return {                                                                                   \
+            .x = static_cast<T>(lhs.x op rhs.x),                                                   \
+            .y = static_cast<T>(lhs.y op rhs.y),                                                   \
+        };                                                                                         \
+    }                                                                                              \
+    friend constexpr Point operator op(const Point& lhs, T value) noexcept {                       \
+        return {                                                                                   \
+            .x = static_cast<T>(lhs.x op value),                                                   \
+            .y = static_cast<T>(lhs.y op value),                                                   \
+        };                                                                                         \
+    }                                                                                              \
+    friend constexpr Point operator op(T value, const Point& rhs) noexcept {                       \
+        return {                                                                                   \
+            .x = static_cast<T>(value op rhs.x),                                                   \
+            .y = static_cast<T>(value op rhs.y),                                                   \
+        };                                                                                         \
+    }                                                                                              \
+    friend constexpr Point& operator compound_op(Point& lhs, const Point& rhs) noexcept {          \
+        lhs.x = static_cast<T>(lhs.x op rhs.x);                                                    \
+        lhs.y = static_cast<T>(lhs.y op rhs.y);                                                    \
+        return lhs;                                                                                \
+    }                                                                                              \
+    friend constexpr Point& operator compound_op(Point& lhs, T value) noexcept {                   \
+        lhs.x = static_cast<T>(lhs.x op value);                                                    \
+        lhs.y = static_cast<T>(lhs.y op value);                                                    \
+        return lhs;                                                                                \
+    }
+    ARITHMETIC_OP(+, +=)
+    ARITHMETIC_OP(-, -=)
+    ARITHMETIC_OP(*, *=)
+    ARITHMETIC_OP(/, /=)
+#undef ARITHMETIC_OP
+
+    friend constexpr bool operator==(const Point&, const Point&) = default;
+};
+
+} // namespace Common

src/common/settings.cpp

@@ -5,7 +5,7 @@
 #include <string_view>
 
 #include "common/assert.h"
-#include "common/file_util.h"
+#include "common/fs/path_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
 
@@ -34,6 +34,10 @@ void LogSettings() {
         LOG_INFO(Config, "{}: {}", name, value);
     };
 
+    const auto log_path = [](std::string_view name, const std::filesystem::path& path) {
+        LOG_INFO(Config, "{}: {}", name, Common::FS::PathToUTF8String(path));
+    };
+
     LOG_INFO(Config, "yuzu Configuration:");
     log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
     log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
@@ -51,19 +55,21 @@ void LogSettings() {
     log_setting("Renderer_UseAsynchronousGpuEmulation",
                 values.use_asynchronous_gpu_emulation.GetValue());
     log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
+    log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
     log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
     log_setting("Renderer_UseAssemblyShaders", values.use_assembly_shaders.GetValue());
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
+    log_setting("Renderer_UseGarbageCollection", values.use_caches_gc.GetValue());
     log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
     log_setting("Audio_OutputEngine", values.sink_id);
     log_setting("Audio_EnableAudioStretching", values.enable_audio_stretching.GetValue());
     log_setting("Audio_OutputDevice", values.audio_device_id);
     log_setting("DataStorage_UseVirtualSd", values.use_virtual_sd);
-    log_setting("DataStorage_CacheDir", Common::FS::GetUserPath(Common::FS::UserPath::CacheDir));
-    log_setting("DataStorage_ConfigDir", Common::FS::GetUserPath(Common::FS::UserPath::ConfigDir));
-    log_setting("DataStorage_LoadDir", Common::FS::GetUserPath(Common::FS::UserPath::LoadDir));
-    log_setting("DataStorage_NandDir", Common::FS::GetUserPath(Common::FS::UserPath::NANDDir));
-    log_setting("DataStorage_SdmcDir", Common::FS::GetUserPath(Common::FS::UserPath::SDMCDir));
+    log_path("DataStorage_CacheDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::CacheDir));
+    log_path("DataStorage_ConfigDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::ConfigDir));
+    log_path("DataStorage_LoadDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::LoadDir));
+    log_path("DataStorage_NANDDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir));
+    log_path("DataStorage_SDMCDir", Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir));
     log_setting("Debugging_ProgramArgs", values.program_args);
     log_setting("Services_BCATBackend", values.bcat_backend);
     log_setting("Services_BCATBoxcatLocal", values.bcat_boxcat_local);
@@ -86,6 +92,13 @@ bool IsGPULevelHigh() {
            values.gpu_accuracy.GetValue() == GPUAccuracy::High;
 }
 
+bool IsFastmemEnabled() {
+    if (values.cpu_accuracy.GetValue() == CPUAccuracy::DebugMode) {
+        return values.cpuopt_fastmem;
+    }
+    return true;
+}
+
 float Volume() {
     if (values.audio_muted) {
         return 0.0f;
@@ -111,6 +124,7 @@ void RestoreGlobalState(bool is_powered_on) {
     values.cpuopt_unsafe_unfuse_fma.SetGlobal(true);
     values.cpuopt_unsafe_reduce_fp_error.SetGlobal(true);
     values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
+    values.cpuopt_unsafe_fastmem_check.SetGlobal(true);
 
     // Renderer
     values.renderer_backend.SetGlobal(true);
@@ -123,10 +137,12 @@ void RestoreGlobalState(bool is_powered_on) {
     values.gpu_accuracy.SetGlobal(true);
     values.use_asynchronous_gpu_emulation.SetGlobal(true);
     values.use_nvdec_emulation.SetGlobal(true);
+    values.accelerate_astc.SetGlobal(true);
     values.use_vsync.SetGlobal(true);
     values.use_assembly_shaders.SetGlobal(true);
     values.use_asynchronous_shaders.SetGlobal(true);
     values.use_fast_gpu_time.SetGlobal(true);
+    values.use_caches_gc.SetGlobal(true);
     values.bg_red.SetGlobal(true);
     values.bg_green.SetGlobal(true);
     values.bg_blue.SetGlobal(true);

src/common/settings.h

@@ -125,10 +125,12 @@ struct Values {
     bool cpuopt_const_prop;
     bool cpuopt_misc_ir;
     bool cpuopt_reduce_misalign_checks;
+    bool cpuopt_fastmem;
 
     Setting<bool> cpuopt_unsafe_unfuse_fma;
     Setting<bool> cpuopt_unsafe_reduce_fp_error;
     Setting<bool> cpuopt_unsafe_inaccurate_nan;
+    Setting<bool> cpuopt_unsafe_fastmem_check;
 
     // Renderer
     Setting<RendererBackend> renderer_backend;
@@ -145,10 +147,12 @@ struct Values {
     Setting<GPUAccuracy> gpu_accuracy;
     Setting<bool> use_asynchronous_gpu_emulation;
     Setting<bool> use_nvdec_emulation;
+    Setting<bool> accelerate_astc;
     Setting<bool> use_vsync;
     Setting<bool> use_assembly_shaders;
     Setting<bool> use_asynchronous_shaders;
     Setting<bool> use_fast_gpu_time;
+    Setting<bool> use_caches_gc;
 
     Setting<float> bg_red;
     Setting<float> bg_green;
@@ -216,6 +220,7 @@ struct Values {
     std::string program_args;
     bool dump_exefs;
     bool dump_nso;
+    bool enable_fs_access_log;
     bool reporting_services;
     bool quest_flag;
     bool disable_macro_jit;
@@ -249,6 +254,8 @@ void SetConfiguringGlobal(bool is_global);
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();
 
+bool IsFastmemEnabled();
+
 float Volume();
 
 std::string GetTimeZoneString();

src/common/string_util.cpp

@@ -9,7 +9,6 @@
 #include <locale>
 #include <sstream>
 
-#include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 
@@ -93,18 +92,6 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     return true;
 }
 
-void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path,
-                           const std::string& _Filename) {
-    _CompleteFilename = _Path;
-
-    // check for seperator
-    if (DIR_SEP_CHR != *_CompleteFilename.rbegin())
-        _CompleteFilename += DIR_SEP_CHR;
-
-    // add the filename
-    _CompleteFilename += _Filename;
-}
-
 void SplitString(const std::string& str, const char delim, std::vector<std::string>& output) {
     std::istringstream iss(str);
     output.resize(1);

src/common/string_util.h

@@ -32,8 +32,6 @@ void SplitString(const std::string& str, char delim, std::vector<std::string>& o
 bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
                std::string* _pExtension);
 
-void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path,
-                           const std::string& _Filename);
 [[nodiscard]] std::string ReplaceAll(std::string result, const std::string& src,
                                      const std::string& dest);
 

src/core/arm/arm_interface.h

@@ -65,9 +65,6 @@ public:
     /// Step CPU by one instruction
     virtual void Step() = 0;
 
-    /// Exits execution from a callback, the callback must rewind the stack
-    virtual void ExceptionalExit() = 0;
-
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
 
@@ -159,8 +156,6 @@ public:
      */
     virtual void SetTPIDR_EL0(u64 value) = 0;
 
-    virtual void ChangeProcessorID(std::size_t new_core_id) = 0;
-
     virtual void SaveContext(ThreadContext32& ctx) = 0;
     virtual void SaveContext(ThreadContext64& ctx) = 0;
     virtual void LoadContext(const ThreadContext32& ctx) = 0;

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -4,9 +4,9 @@
 
 #include <cinttypes>
 #include <memory>
-#include <dynarmic/A32/a32.h>
-#include <dynarmic/A32/config.h>
-#include <dynarmic/A32/context.h>
+#include <dynarmic/interface/A32/a32.h>
+#include <dynarmic/interface/A32/config.h>
+#include <dynarmic/interface/A32/context.h>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
@@ -24,45 +24,46 @@ namespace Core {
 
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
-    explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_) : parent{parent_} {}
+    explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
+        : parent{parent_}, memory(parent.system.Memory()) {}
 
     u8 MemoryRead8(u32 vaddr) override {
-        return parent.system.Memory().Read8(vaddr);
+        return memory.Read8(vaddr);
     }
     u16 MemoryRead16(u32 vaddr) override {
-        return parent.system.Memory().Read16(vaddr);
+        return memory.Read16(vaddr);
     }
     u32 MemoryRead32(u32 vaddr) override {
-        return parent.system.Memory().Read32(vaddr);
+        return memory.Read32(vaddr);
     }
     u64 MemoryRead64(u32 vaddr) override {
-        return parent.system.Memory().Read64(vaddr);
+        return memory.Read64(vaddr);
     }
 
     void MemoryWrite8(u32 vaddr, u8 value) override {
-        parent.system.Memory().Write8(vaddr, value);
+        memory.Write8(vaddr, value);
     }
     void MemoryWrite16(u32 vaddr, u16 value) override {
-        parent.system.Memory().Write16(vaddr, value);
+        memory.Write16(vaddr, value);
     }
     void MemoryWrite32(u32 vaddr, u32 value) override {
-        parent.system.Memory().Write32(vaddr, value);
+        memory.Write32(vaddr, value);
     }
     void MemoryWrite64(u32 vaddr, u64 value) override {
-        parent.system.Memory().Write64(vaddr, value);
+        memory.Write64(vaddr, value);
     }
 
     bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override {
-        return parent.system.Memory().WriteExclusive8(vaddr, value, expected);
+        return memory.WriteExclusive8(vaddr, value, expected);
     }
     bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override {
-        return parent.system.Memory().WriteExclusive16(vaddr, value, expected);
+        return memory.WriteExclusive16(vaddr, value, expected);
     }
     bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override {
-        return parent.system.Memory().WriteExclusive32(vaddr, value, expected);
+        return memory.WriteExclusive32(vaddr, value, expected);
     }
     bool MemoryWriteExclusive64(u32 vaddr, u64 value, u64 expected) override {
-        return parent.system.Memory().WriteExclusive64(vaddr, value, expected);
+        return memory.WriteExclusive64(vaddr, value, expected);
     }
 
     void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
@@ -78,7 +79,9 @@ public:
     }
 
     void CallSVC(u32 swi) override {
-        Kernel::Svc::Call(parent.system, swi);
+        parent.svc_called = true;
+        parent.svc_swi = swi;
+        parent.jit->HaltExecution();
     }
 
     void AddTicks(u64 ticks) override {
@@ -110,6 +113,7 @@ public:
     }
 
     ARM_Dynarmic_32& parent;
+    Core::Memory::Memory& memory;
     std::size_t num_interpreted_instructions{};
     static constexpr u64 minimum_run_cycles = 1000U;
 };
@@ -124,6 +128,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     if (page_table) {
         config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>(
             page_table->pointers.data());
+        config.fastmem_pointer = page_table->fastmem_arena;
     }
     config.absolute_offset_page_table = true;
     config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
@@ -139,7 +144,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
 
     // Code cache size
     config.code_cache_size = 512 * 1024 * 1024;
-    config.far_code_offset = 256 * 1024 * 1024;
+    config.far_code_offset = 400 * 1024 * 1024;
 
     // Safe optimizations
     if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
@@ -167,6 +172,9 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_reduce_misalign_checks) {
             config.only_detect_misalignment_via_page_table_on_page_boundary = false;
         }
+        if (!Settings::values.cpuopt_fastmem) {
+            config.fastmem_pointer = nullptr;
+        }
     }
 
     // Unsafe optimizations
@@ -187,11 +195,17 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
 }
 
 void ARM_Dynarmic_32::Run() {
-    jit->Run();
-}
-
-void ARM_Dynarmic_32::ExceptionalExit() {
-    jit->ExceptionalExit();
+    while (true) {
+        jit->Run();
+        if (!svc_called) {
+            break;
+        }
+        svc_called = false;
+        Kernel::Svc::Call(system, svc_swi);
+        if (shutdown) {
+            break;
+        }
+    }
 }
 
 void ARM_Dynarmic_32::Step() {
@@ -255,10 +269,6 @@ void ARM_Dynarmic_32::SetTPIDR_EL0(u64 value) {
     cp15->uprw = static_cast<u32>(value);
 }
 
-void ARM_Dynarmic_32::ChangeProcessorID(std::size_t new_core_id) {
-    jit->ChangeProcessorID(new_core_id);
-}
-
 void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {
     Dynarmic::A32::Context context;
     jit->SaveContext(context);
@@ -279,6 +289,7 @@ void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) {
 
 void ARM_Dynarmic_32::PrepareReschedule() {
     jit->HaltExecution();
+    shutdown = true;
 }
 
 void ARM_Dynarmic_32::ClearInstructionCache() {

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -7,9 +7,9 @@
 #include <memory>
 #include <unordered_map>
 
-#include <dynarmic/A32/a32.h>
-#include <dynarmic/A64/a64.h>
-#include <dynarmic/exclusive_monitor.h>
+#include <dynarmic/interface/A32/a32.h>
+#include <dynarmic/interface/A64/a64.h>
+#include <dynarmic/interface/exclusive_monitor.h>
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
@@ -42,13 +42,11 @@ public:
     u32 GetPSTATE() const override;
     void SetPSTATE(u32 pstate) override;
     void Run() override;
-    void ExceptionalExit() override;
     void Step() override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
     void SetTPIDR_EL0(u64 value) override;
     u64 GetTPIDR_EL0() const override;
-    void ChangeProcessorID(std::size_t new_core_id) override;
 
     bool IsInThumbMode() const {
         return (GetPSTATE() & 0x20) != 0;
@@ -83,6 +81,12 @@ private:
     std::size_t core_index;
     DynarmicExclusiveMonitor& exclusive_monitor;
     std::shared_ptr<Dynarmic::A32::Jit> jit;
+
+    // SVC callback
+    u32 svc_swi{};
+    bool svc_called{};
+
+    bool shutdown{};
 };
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -4,8 +4,8 @@
 
 #include <cinttypes>
 #include <memory>
-#include <dynarmic/A64/a64.h>
-#include <dynarmic/A64/config.h>
+#include <dynarmic/interface/A64/a64.h>
+#include <dynarmic/interface/A64/config.h>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
@@ -27,57 +27,56 @@ using Vector = Dynarmic::A64::Vector;
 
 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
-    explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_) : parent{parent_} {}
+    explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
+        : parent{parent_}, memory(parent.system.Memory()) {}
 
     u8 MemoryRead8(u64 vaddr) override {
-        return parent.system.Memory().Read8(vaddr);
+        return memory.Read8(vaddr);
     }
     u16 MemoryRead16(u64 vaddr) override {
-        return parent.system.Memory().Read16(vaddr);
+        return memory.Read16(vaddr);
     }
     u32 MemoryRead32(u64 vaddr) override {
-        return parent.system.Memory().Read32(vaddr);
+        return memory.Read32(vaddr);
     }
     u64 MemoryRead64(u64 vaddr) override {
-        return parent.system.Memory().Read64(vaddr);
+        return memory.Read64(vaddr);
     }
     Vector MemoryRead128(u64 vaddr) override {
-        auto& memory = parent.system.Memory();
         return {memory.Read64(vaddr), memory.Read64(vaddr + 8)};
     }
 
     void MemoryWrite8(u64 vaddr, u8 value) override {
-        parent.system.Memory().Write8(vaddr, value);
+        memory.Write8(vaddr, value);
     }
     void MemoryWrite16(u64 vaddr, u16 value) override {
-        parent.system.Memory().Write16(vaddr, value);
+        memory.Write16(vaddr, value);
     }
     void MemoryWrite32(u64 vaddr, u32 value) override {
-        parent.system.Memory().Write32(vaddr, value);
+        memory.Write32(vaddr, value);
     }
     void MemoryWrite64(u64 vaddr, u64 value) override {
-        parent.system.Memory().Write64(vaddr, value);
+        memory.Write64(vaddr, value);
     }
     void MemoryWrite128(u64 vaddr, Vector value) override {
-        auto& memory = parent.system.Memory();
         memory.Write64(vaddr, value[0]);
         memory.Write64(vaddr + 8, value[1]);
     }
 
     bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override {
-        return parent.system.Memory().WriteExclusive8(vaddr, value, expected);
+        return memory.WriteExclusive8(vaddr, value, expected);
     }
     bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override {
-        return parent.system.Memory().WriteExclusive16(vaddr, value, expected);
+        return memory.WriteExclusive16(vaddr, value, expected);
     }
     bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, std::uint32_t expected) override {
-        return parent.system.Memory().WriteExclusive32(vaddr, value, expected);
+        return memory.WriteExclusive32(vaddr, value, expected);
     }
     bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, std::uint64_t expected) override {
-        return parent.system.Memory().WriteExclusive64(vaddr, value, expected);
+        return memory.WriteExclusive64(vaddr, value, expected);
     }
     bool MemoryWriteExclusive128(u64 vaddr, Vector value, Vector expected) override {
-        return parent.system.Memory().WriteExclusive128(vaddr, value, expected);
+        return memory.WriteExclusive128(vaddr, value, expected);
     }
 
     void InterpreterFallback(u64 pc, std::size_t num_instructions) override {
@@ -102,7 +101,9 @@ public:
     }
 
     void CallSVC(u32 swi) override {
-        Kernel::Svc::Call(parent.system, swi);
+        parent.svc_called = true;
+        parent.svc_swi = swi;
+        parent.jit->HaltExecution();
     }
 
     void AddTicks(u64 ticks) override {
@@ -137,6 +138,7 @@ public:
     }
 
     ARM_Dynarmic_64& parent;
+    Core::Memory::Memory& memory;
     u64 tpidrro_el0 = 0;
     u64 tpidr_el0 = 0;
     static constexpr u64 minimum_run_cycles = 1000U;
@@ -158,6 +160,10 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
         config.only_detect_misalignment_via_page_table_on_page_boundary = true;
+
+        config.fastmem_pointer = page_table->fastmem_arena;
+        config.fastmem_address_space_bits = address_space_bits;
+        config.silently_mirror_fastmem = false;
     }
 
     // Multi-process state
@@ -179,7 +185,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
 
     // Code cache size
     config.code_cache_size = 512 * 1024 * 1024;
-    config.far_code_offset = 256 * 1024 * 1024;
+    config.far_code_offset = 400 * 1024 * 1024;
 
     // Safe optimizations
     if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::DebugMode) {
@@ -207,6 +213,9 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_reduce_misalign_checks) {
             config.only_detect_misalignment_via_page_table_on_page_boundary = false;
         }
+        if (!Settings::values.cpuopt_fastmem) {
+            config.fastmem_pointer = nullptr;
+        }
     }
 
     // Unsafe optimizations
@@ -221,17 +230,26 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue()) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }
+        if (Settings::values.cpuopt_unsafe_fastmem_check.GetValue()) {
+            config.fastmem_address_space_bits = 64;
+        }
     }
 
     return std::make_shared<Dynarmic::A64::Jit>(config);
 }
 
 void ARM_Dynarmic_64::Run() {
-    jit->Run();
-}
-
-void ARM_Dynarmic_64::ExceptionalExit() {
-    jit->ExceptionalExit();
+    while (true) {
+        jit->Run();
+        if (!svc_called) {
+            break;
+        }
+        svc_called = false;
+        Kernel::Svc::Call(system, svc_swi);
+        if (shutdown) {
+            break;
+        }
+    }
 }
 
 void ARM_Dynarmic_64::Step() {
@@ -296,10 +314,6 @@ void ARM_Dynarmic_64::SetTPIDR_EL0(u64 value) {
     cb->tpidr_el0 = value;
 }
 
-void ARM_Dynarmic_64::ChangeProcessorID(std::size_t new_core_id) {
-    jit->ChangeProcessorID(new_core_id);
-}
-
 void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();
@@ -324,6 +338,7 @@ void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
 
 void ARM_Dynarmic_64::PrepareReschedule() {
     jit->HaltExecution();
+    shutdown = true;
 }
 
 void ARM_Dynarmic_64::ClearInstructionCache() {

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <unordered_map>
 
-#include <dynarmic/A64/a64.h>
+#include <dynarmic/interface/A64/a64.h>
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
@@ -40,12 +40,10 @@ public:
     void SetPSTATE(u32 pstate) override;
     void Run() override;
     void Step() override;
-    void ExceptionalExit() override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
     void SetTPIDR_EL0(u64 value) override;
     u64 GetTPIDR_EL0() const override;
-    void ChangeProcessorID(std::size_t new_core_id) override;
 
     void SaveContext(ThreadContext32& ctx) override {}
     void SaveContext(ThreadContext64& ctx) override;
@@ -76,6 +74,12 @@ private:
     DynarmicExclusiveMonitor& exclusive_monitor;
 
     std::shared_ptr<Dynarmic::A64::Jit> jit;
+
+    // SVC callback
+    u32 svc_swi{};
+    bool svc_called{};
+
+    bool shutdown{};
 };
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_cp15.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <optional>
 
-#include <dynarmic/A32/coprocessor.h>
+#include <dynarmic/interface/A32/coprocessor.h>
 #include "common/common_types.h"
 
 namespace Core {

src/core/arm/dynarmic/arm_exclusive_monitor.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <unordered_map>
 
-#include <dynarmic/exclusive_monitor.h>
+#include <dynarmic/interface/exclusive_monitor.h>
 
 #include "common/common_types.h"
 #include "core/arm/dynarmic/arm_dynarmic_32.h"

src/core/core.cpp

@@ -6,7 +6,7 @@
 #include <memory>
 #include <utility>
 
-#include "common/file_util.h"
+#include "common/fs/fs.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/settings.h"
@@ -121,7 +121,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
                                                                   dir->GetName());
     }
 
-    if (Common::FS::IsDirectory(path)) {
+    if (Common::FS::IsDir(path)) {
         return vfs->OpenFile(path + "/main", FileSys::Mode::Read);
     }
 

src/core/crypto/key_manager.cpp

@@ -18,8 +18,9 @@
 #include <mbedtls/cmac.h>
 #include <mbedtls/sha256.h>
 #include "common/common_funcs.h"
-#include "common/common_paths.h"
-#include "common/file_util.h"
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
@@ -325,46 +326,55 @@ Key128 DeriveKeyblobMACKey(const Key128& keyblob_key, const Key128& mac_source)
 }
 
 std::optional<Key128> DeriveSDSeed() {
-    const Common::FS::IOFile save_43(Common::FS::GetUserPath(Common::FS::UserPath::NANDDir) +
-                                         "/system/save/8000000000000043",
-                                     "rb+");
+    const auto system_save_43_path =
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) / "system/save/8000000000000043";
+    const Common::FS::IOFile save_43{system_save_43_path, Common::FS::FileAccessMode::Read,
+                                     Common::FS::FileType::BinaryFile};
+
     if (!save_43.IsOpen()) {
         return std::nullopt;
     }
 
-    const Common::FS::IOFile sd_private(Common::FS::GetUserPath(Common::FS::UserPath::SDMCDir) +
-                                            "/Nintendo/Contents/private",
-                                        "rb+");
+    const auto sd_private_path =
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::SDMCDir) / "Nintendo/Contents/private";
+
+    const Common::FS::IOFile sd_private{sd_private_path, Common::FS::FileAccessMode::Read,
+                                        Common::FS::FileType::BinaryFile};
+
     if (!sd_private.IsOpen()) {
         return std::nullopt;
     }
 
     std::array<u8, 0x10> private_seed{};
-    if (sd_private.ReadBytes(private_seed.data(), private_seed.size()) != private_seed.size()) {
+    if (sd_private.Read(private_seed) != private_seed.size()) {
         return std::nullopt;
     }
 
     std::array<u8, 0x10> buffer{};
-    std::size_t offset = 0;
-    for (; offset + 0x10 < save_43.GetSize(); ++offset) {
-        if (!save_43.Seek(offset, SEEK_SET)) {
+    s64 offset = 0;
+    for (; offset + 0x10 < static_cast<s64>(save_43.GetSize()); ++offset) {
+        if (!save_43.Seek(offset)) {
+            return std::nullopt;
+        }
+
+        if (save_43.Read(buffer) != buffer.size()) {
             return std::nullopt;
         }
 
-        save_43.ReadBytes(buffer.data(), buffer.size());
         if (buffer == private_seed) {
             break;
         }
     }
 
-    if (!save_43.Seek(offset + 0x10, SEEK_SET)) {
+    if (!save_43.Seek(offset + 0x10)) {
         return std::nullopt;
     }
 
     Key128 seed{};
-    if (save_43.ReadBytes(seed.data(), seed.size()) != seed.size()) {
+    if (save_43.Read(seed) != seed.size()) {
         return std::nullopt;
     }
+
     return seed;
 }
 
@@ -435,7 +445,7 @@ std::vector<Ticket> GetTicketblob(const Common::FS::IOFile& ticket_save) {
     }
 
     std::vector<u8> buffer(ticket_save.GetSize());
-    if (ticket_save.ReadBytes(buffer.data(), buffer.size()) != buffer.size()) {
+    if (ticket_save.Read(buffer) != buffer.size()) {
         return {};
     }
 
@@ -566,27 +576,26 @@ std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
 
 KeyManager::KeyManager() {
     // Initialize keys
-    const std::string hactool_keys_dir = Common::FS::GetHactoolConfigurationPath();
-    const std::string yuzu_keys_dir = Common::FS::GetUserPath(Common::FS::UserPath::KeysDir);
+    const auto yuzu_keys_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::KeysDir);
 
-    if (!Common::FS::Exists(yuzu_keys_dir)) {
-        Common::FS::CreateDir(yuzu_keys_dir);
+    if (!Common::FS::CreateDir(yuzu_keys_dir)) {
+        LOG_ERROR(Core, "Failed to create the keys directory.");
     }
 
     if (Settings::values.use_dev_keys) {
         dev_mode = true;
-        AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "dev.keys", false);
-        AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "dev.keys_autogenerated", false);
+        LoadFromFile(yuzu_keys_dir / "dev.keys", false);
+        LoadFromFile(yuzu_keys_dir / "dev.keys_autogenerated", false);
     } else {
         dev_mode = false;
-        AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "prod.keys", false);
-        AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "prod.keys_autogenerated", false);
+        LoadFromFile(yuzu_keys_dir / "prod.keys", false);
+        LoadFromFile(yuzu_keys_dir / "prod.keys_autogenerated", false);
     }
 
-    AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "title.keys", true);
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "title.keys_autogenerated", true);
-    AttemptLoadKeyFile(yuzu_keys_dir, hactool_keys_dir, "console.keys", false);
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, "console.keys_autogenerated", false);
+    LoadFromFile(yuzu_keys_dir / "title.keys", true);
+    LoadFromFile(yuzu_keys_dir / "title.keys_autogenerated", true);
+    LoadFromFile(yuzu_keys_dir / "console.keys", false);
+    LoadFromFile(yuzu_keys_dir / "console.keys_autogenerated", false);
 }
 
 static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_t length) {
@@ -597,9 +606,14 @@ static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_
                        [](u8 c) { return std::isxdigit(c); });
 }
 
-void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
+void KeyManager::LoadFromFile(const std::filesystem::path& file_path, bool is_title_keys) {
+    if (!Common::FS::Exists(file_path)) {
+        return;
+    }
+
     std::ifstream file;
-    Common::FS::OpenFStream(file, filename, std::ios_base::in);
+    Common::FS::OpenFileStream(file, file_path, std::ios_base::in);
+
     if (!file.is_open()) {
         return;
     }
@@ -694,15 +708,6 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
     }
 }
 
-void KeyManager::AttemptLoadKeyFile(const std::string& dir1, const std::string& dir2,
-                                    const std::string& filename, bool title) {
-    if (Common::FS::Exists(dir1 + DIR_SEP + filename)) {
-        LoadFromFile(dir1 + DIR_SEP + filename, title);
-    } else if (Common::FS::Exists(dir2 + DIR_SEP + filename)) {
-        LoadFromFile(dir2 + DIR_SEP + filename, title);
-    }
-}
-
 bool KeyManager::BaseDeriveNecessary() const {
     const auto check_key_existence = [this](auto key_type, u64 index1 = 0, u64 index2 = 0) {
         return !HasKey(key_type, index1, index2);
@@ -766,30 +771,35 @@ Key256 KeyManager::GetBISKey(u8 partition_id) const {
 template <size_t Size>
 void KeyManager::WriteKeyToFile(KeyCategory category, std::string_view keyname,
                                 const std::array<u8, Size>& key) {
-    const std::string yuzu_keys_dir = Common::FS::GetUserPath(Common::FS::UserPath::KeysDir);
+    const auto yuzu_keys_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::KeysDir);
+
     std::string filename = "title.keys_autogenerated";
+
     if (category == KeyCategory::Standard) {
         filename = dev_mode ? "dev.keys_autogenerated" : "prod.keys_autogenerated";
     } else if (category == KeyCategory::Console) {
         filename = "console.keys_autogenerated";
     }
 
-    const auto path = yuzu_keys_dir + DIR_SEP + filename;
+    const auto path = yuzu_keys_dir / filename;
     const auto add_info_text = !Common::FS::Exists(path);
-    Common::FS::CreateFullPath(path);
-    Common::FS::IOFile file{path, "a"};
+
+    Common::FS::IOFile file{path, Common::FS::FileAccessMode::Append,
+                            Common::FS::FileType::TextFile};
+
     if (!file.IsOpen()) {
         return;
     }
+
     if (add_info_text) {
-        file.WriteString(
+        void(file.WriteString(
             "# This file is autogenerated by Yuzu\n"
             "# It serves to store keys that were automatically generated from the normal keys\n"
-            "# If you are experiencing issues involving keys, it may help to delete this file\n");
+            "# If you are experiencing issues involving keys, it may help to delete this file\n"));
     }
 
-    file.WriteString(fmt::format("\n{} = {}", keyname, Common::HexToString(key)));
-    AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, filename, category == KeyCategory::Title);
+    void(file.WriteString(fmt::format("\n{} = {}", keyname, Common::HexToString(key))));
+    LoadFromFile(path, category == KeyCategory::Title);
 }
 
 void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
@@ -861,20 +871,17 @@ void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
 }
 
 bool KeyManager::KeyFileExists(bool title) {
-    const std::string hactool_keys_dir = Common::FS::GetHactoolConfigurationPath();
-    const std::string yuzu_keys_dir = Common::FS::GetUserPath(Common::FS::UserPath::KeysDir);
+    const auto yuzu_keys_dir = Common::FS::GetYuzuPath(Common::FS::YuzuPath::KeysDir);
+
     if (title) {
-        return Common::FS::Exists(hactool_keys_dir + DIR_SEP + "title.keys") ||
-               Common::FS::Exists(yuzu_keys_dir + DIR_SEP + "title.keys");
+        return Common::FS::Exists(yuzu_keys_dir / "title.keys");
     }
 
     if (Settings::values.use_dev_keys) {
-        return Common::FS::Exists(hactool_keys_dir + DIR_SEP + "dev.keys") ||
-               Common::FS::Exists(yuzu_keys_dir + DIR_SEP + "dev.keys");
+        return Common::FS::Exists(yuzu_keys_dir / "dev.keys");
     }
 
-    return Common::FS::Exists(hactool_keys_dir + DIR_SEP + "prod.keys") ||
-           Common::FS::Exists(yuzu_keys_dir + DIR_SEP + "prod.keys");
+    return Common::FS::Exists(yuzu_keys_dir / "prod.keys");
 }
 
 void KeyManager::DeriveSDSeedLazy() {
@@ -1115,15 +1122,21 @@ void KeyManager::PopulateTickets() {
         return;
     }
 
-    const Common::FS::IOFile save1(Common::FS::GetUserPath(Common::FS::UserPath::NANDDir) +
-                                       "/system/save/80000000000000e1",
-                                   "rb+");
-    const Common::FS::IOFile save2(Common::FS::GetUserPath(Common::FS::UserPath::NANDDir) +
-                                       "/system/save/80000000000000e2",
-                                   "rb+");
+    const auto system_save_e1_path =
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) / "system/save/80000000000000e1";
+
+    const Common::FS::IOFile save_e1{system_save_e1_path, Common::FS::FileAccessMode::Read,
+                                     Common::FS::FileType::BinaryFile};
+
+    const auto system_save_e2_path =
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) / "system/save/80000000000000e2";
+
+    const Common::FS::IOFile save_e2{system_save_e2_path, Common::FS::FileAccessMode::Read,
+                                     Common::FS::FileType::BinaryFile};
+
+    const auto blob2 = GetTicketblob(save_e2);
+    auto res = GetTicketblob(save_e1);
 
-    const auto blob2 = GetTicketblob(save2);
-    auto res = GetTicketblob(save1);
     const auto idx = res.size();
     res.insert(res.end(), blob2.begin(), blob2.end());
 

src/core/crypto/key_manager.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <filesystem>
 #include <map>
 #include <optional>
 #include <string>
@@ -283,9 +284,8 @@ private:
     std::array<u8, 576> eticket_extended_kek{};
 
     bool dev_mode;
-    void LoadFromFile(const std::string& filename, bool is_title_keys);
-    void AttemptLoadKeyFile(const std::string& dir1, const std::string& dir2,
-                            const std::string& filename, bool title);
+    void LoadFromFile(const std::filesystem::path& file_path, bool is_title_keys);
+
     template <size_t Size>
     void WriteKeyToFile(KeyCategory category, std::string_view keyname,
                         const std::array<u8, Size>& key);

src/core/device_memory.cpp

@@ -6,7 +6,7 @@
 
 namespace Core {
 
-DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size} {}
+DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size, 1ULL << 39} {}
 DeviceMemory::~DeviceMemory() = default;
 
 } // namespace Core

src/core/device_memory.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "common/virtual_buffer.h"
+#include "common/host_memory.h"
 
 namespace Core {
 
@@ -21,27 +21,30 @@ enum : u64 {
 };
 }; // namespace DramMemoryMap
 
-class DeviceMemory : NonCopyable {
+class DeviceMemory {
 public:
     explicit DeviceMemory();
     ~DeviceMemory();
 
+    DeviceMemory& operator=(const DeviceMemory&) = delete;
+    DeviceMemory(const DeviceMemory&) = delete;
+
     template <typename T>
     PAddr GetPhysicalAddr(const T* ptr) const {
-        return (reinterpret_cast<uintptr_t>(ptr) - reinterpret_cast<uintptr_t>(buffer.data())) +
+        return (reinterpret_cast<uintptr_t>(ptr) -
+                reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
                DramMemoryMap::Base;
     }
 
     u8* GetPointer(PAddr addr) {
-        return buffer.data() + (addr - DramMemoryMap::Base);
+        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
     }
 
     const u8* GetPointer(PAddr addr) const {
-        return buffer.data() + (addr - DramMemoryMap::Base);
+        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
     }
 
-private:
-    Common::VirtualBuffer<u8> buffer;
+    Common::HostMemory buffer;
 };
 
 } // namespace Core

src/core/file_sys/bis_factory.cpp

@@ -3,7 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <fmt/format.h>
-#include "common/file_util.h"
+#include "common/fs/path_util.h"
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/registered_cache.h"
@@ -85,7 +85,7 @@ VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id,
                                              VirtualFilesystem file_system) const {
     auto& keys = Core::Crypto::KeyManager::Instance();
     Core::Crypto::PartitionDataManager pdm{file_system->OpenDirectory(
-        Common::FS::GetUserPath(Common::FS::UserPath::SysDataDir), Mode::Read)};
+        Common::FS::GetYuzuPathString(Common::FS::YuzuPath::NANDDir), Mode::Read)};
     keys.PopulateFromPartitionData(pdm);
 
     switch (id) {

src/core/file_sys/mode.h

@@ -10,11 +10,13 @@
 namespace FileSys {
 
 enum class Mode : u32 {
-    Read = 1,
-    Write = 2,
+    Read = 1 << 0,
+    Write = 1 << 1,
     ReadWrite = Read | Write,
-    Append = 4,
+    Append = 1 << 2,
+    ReadAppend = Read | Append,
     WriteAppend = Write | Append,
+    All = ReadWrite | Append,
 };
 
 DECLARE_ENUM_FLAG_OPERATORS(Mode)

src/core/file_sys/partition_filesystem.cpp

@@ -8,7 +8,6 @@
 #include <iterator>
 #include <utility>
 
-#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/vfs_offset.h"

src/core/file_sys/patch_manager.cpp

@@ -7,7 +7,6 @@
 #include <cstddef>
 #include <cstring>
 
-#include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"

src/core/file_sys/program_metadata.cpp

@@ -150,7 +150,9 @@ void ProgramMetadata::Print() const {
     LOG_DEBUG(Service_FS, " > Is Retail:           {}", acid_header.is_retail ? "YES" : "NO");
     LOG_DEBUG(Service_FS, "Title ID Min:           0x{:016X}", acid_header.title_id_min);
     LOG_DEBUG(Service_FS, "Title ID Max:           0x{:016X}", acid_header.title_id_max);
-    LOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", acid_file_access.permissions);
+    u64_le permissions_l; // local copy to fix alignment error
+    std::memcpy(&permissions_l, &acid_file_access.permissions, sizeof(permissions_l));
+    LOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", permissions_l);
 
     // Begin ACI0 printing (actual perms, unsigned)
     LOG_DEBUG(Service_FS, "Magic:                  {:.4}", aci_header.magic.data());

src/core/file_sys/registered_cache.cpp

@@ -7,7 +7,7 @@
 #include <regex>
 #include <mbedtls/sha256.h>
 #include "common/assert.h"
-#include "common/file_util.h"
+#include "common/fs/path_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "core/crypto/key_manager.h"

src/core/file_sys/romfs_factory.cpp

@@ -53,7 +53,7 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
 
     if (nca == nullptr) {
         // TODO: Find the right error code to use here
-        return RESULT_UNKNOWN;
+        return ResultUnknown;
     }
 
     const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
@@ -74,13 +74,13 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
     const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
     if (res == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
-        return RESULT_UNKNOWN;
+        return ResultUnknown;
     }
 
     const auto romfs = res->GetRomFS();
     if (romfs == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
-        return RESULT_UNKNOWN;
+        return ResultUnknown;
     }
 
     return MakeResult<VirtualFile>(romfs);

src/core/file_sys/savedata_factory.cpp

@@ -91,7 +91,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
     // Return an error if the save data doesn't actually exist.
     if (out == nullptr) {
         // TODO(DarkLordZach): Find out correct error code.
-        return RESULT_UNKNOWN;
+        return ResultUnknown;
     }
 
     return MakeResult<VirtualDir>(std::move(out));
@@ -105,14 +105,14 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
-    if (out == nullptr && ShouldSaveDataBeAutomaticallyCreated(space, meta)) {
+    if (out == nullptr && (ShouldSaveDataBeAutomaticallyCreated(space, meta) && auto_create)) {
         return Create(space, meta);
     }
 
     // Return an error if the save data doesn't actually exist.
     if (out == nullptr) {
         // TODO(Subv): Find out correct error code.
-        return RESULT_UNKNOWN;
+        return ResultUnknown;
     }
 
     return MakeResult<VirtualDir>(std::move(out));
@@ -199,4 +199,8 @@ void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 us
     size_file->WriteObject(new_value);
 }
 
+void SaveDataFactory::SetAutoCreate(bool state) {
+    auto_create = state;
+}
+
 } // namespace FileSys

src/core/file_sys/savedata_factory.h

@@ -104,9 +104,12 @@ public:
     void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                            SaveDataSize new_value) const;
 
+    void SetAutoCreate(bool state);
+
 private:
     VirtualDir dir;
     Core::System& system;
+    bool auto_create{true};
 };
 
 } // namespace FileSys

src/core/file_sys/vfs.cpp

@@ -5,9 +5,7 @@
 #include <algorithm>
 #include <numeric>
 #include <string>
-#include "common/common_paths.h"
-#include "common/file_util.h"
-#include "common/logging/backend.h"
+#include "common/fs/path_util.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs.h"
 
@@ -122,15 +120,14 @@ VirtualDir VfsFilesystem::CopyDirectory(std::string_view old_path_, std::string_
         return nullptr;
 
     for (const auto& file : old_dir->GetFiles()) {
-        const auto x =
-            CopyFile(old_path + DIR_SEP + file->GetName(), new_path + DIR_SEP + file->GetName());
+        const auto x = CopyFile(old_path + '/' + file->GetName(), new_path + '/' + file->GetName());
         if (x == nullptr)
             return nullptr;
     }
 
     for (const auto& dir : old_dir->GetSubdirectories()) {
         const auto x =
-            CopyDirectory(old_path + DIR_SEP + dir->GetName(), new_path + DIR_SEP + dir->GetName());
+            CopyDirectory(old_path + '/' + dir->GetName(), new_path + '/' + dir->GetName());
         if (x == nullptr)
             return nullptr;
     }

src/core/file_sys/vfs_libzip.cpp

@@ -13,7 +13,7 @@
 #pragma GCC diagnostic pop
 #endif
 
-#include "common/logging/backend.h"
+#include "common/fs/path_util.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_libzip.h"
 #include "core/file_sys/vfs_vector.h"

src/core/file_sys/vfs_real.cpp

@@ -7,8 +7,9 @@
 #include <iterator>
 #include <utility>
 #include "common/assert.h"
-#include "common/common_paths.h"
-#include "common/file_util.h"
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/vfs_real.h"
 
@@ -16,33 +17,31 @@ namespace FileSys {
 
 namespace FS = Common::FS;
 
-static std::string ModeFlagsToString(Mode mode) {
-    std::string mode_str;
+namespace {
 
-    // Calculate the correct open mode for the file.
-    if (True(mode & Mode::Read) && True(mode & Mode::Write)) {
-        if (True(mode & Mode::Append)) {
-            mode_str = "a+";
-        } else {
-            mode_str = "r+";
-        }
-    } else {
-        if (True(mode & Mode::Read)) {
-            mode_str = "r";
-        } else if (True(mode & Mode::Append)) {
-            mode_str = "a";
-        } else if (True(mode & Mode::Write)) {
-            mode_str = "w";
-        } else {
-            UNREACHABLE_MSG("Invalid file open mode: {:02X}", static_cast<u8>(mode));
-        }
+constexpr FS::FileAccessMode ModeFlagsToFileAccessMode(Mode mode) {
+    switch (mode) {
+    case Mode::Read:
+        return FS::FileAccessMode::Read;
+    case Mode::Write:
+        return FS::FileAccessMode::Write;
+    case Mode::ReadWrite:
+        return FS::FileAccessMode::ReadWrite;
+    case Mode::Append:
+        return FS::FileAccessMode::Append;
+    case Mode::ReadAppend:
+        return FS::FileAccessMode::ReadAppend;
+    case Mode::WriteAppend:
+        return FS::FileAccessMode::Append;
+    case Mode::All:
+        return FS::FileAccessMode::ReadAppend;
+    default:
+        return {};
     }
-
-    mode_str += "b";
-
-    return mode_str;
 }
 
+} // Anonymous namespace
+
 RealVfsFilesystem::RealVfsFilesystem() : VfsFilesystem(nullptr) {}
 RealVfsFilesystem::~RealVfsFilesystem() = default;
 
@@ -63,7 +62,7 @@ VfsEntryType RealVfsFilesystem::GetEntryType(std::string_view path_) const {
     if (!FS::Exists(path)) {
         return VfsEntryType::None;
     }
-    if (FS::IsDirectory(path)) {
+    if (FS::IsDir(path)) {
         return VfsEntryType::Directory;
     }
 
@@ -81,12 +80,13 @@ VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) {
         }
     }
 
-    if (!FS::Exists(path) && True(perms & Mode::WriteAppend)) {
-        FS::CreateEmptyFile(path);
+    auto backing = FS::FileOpen(path, ModeFlagsToFileAccessMode(perms), FS::FileType::BinaryFile);
+
+    if (!backing) {
+        return nullptr;
     }
 
-    auto backing = std::make_shared<FS::IOFile>(path, ModeFlagsToString(perms).c_str());
-    cache.insert_or_assign(path, backing);
+    cache.insert_or_assign(path, std::move(backing));
 
     // Cannot use make_shared as RealVfsFile constructor is private
     return std::shared_ptr<RealVfsFile>(new RealVfsFile(*this, backing, path, perms));
@@ -94,25 +94,29 @@ VirtualFile RealVfsFilesystem::OpenFile(std::string_view path_, Mode perms) {
 
 VirtualFile RealVfsFilesystem::CreateFile(std::string_view path_, Mode perms) {
     const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
-    const auto path_fwd = FS::SanitizePath(path, FS::DirectorySeparator::ForwardSlash);
-    if (!FS::Exists(path)) {
-        FS::CreateFullPath(path_fwd);
-        if (!FS::CreateEmptyFile(path)) {
+    // Current usages of CreateFile expect to delete the contents of an existing file.
+    if (FS::IsFile(path)) {
+        FS::IOFile temp{path, FS::FileAccessMode::Write, FS::FileType::BinaryFile};
+
+        if (!temp.IsOpen()) {
             return nullptr;
         }
+
+        temp.Close();
+
+        return OpenFile(path, perms);
     }
+
+    if (!FS::NewFile(path)) {
+        return nullptr;
+    }
+
     return OpenFile(path, perms);
 }
 
 VirtualFile RealVfsFilesystem::CopyFile(std::string_view old_path_, std::string_view new_path_) {
-    const auto old_path = FS::SanitizePath(old_path_, FS::DirectorySeparator::PlatformDefault);
-    const auto new_path = FS::SanitizePath(new_path_, FS::DirectorySeparator::PlatformDefault);
-
-    if (!FS::Exists(old_path) || FS::Exists(new_path) || FS::IsDirectory(old_path) ||
-        !FS::Copy(old_path, new_path)) {
-        return nullptr;
-    }
-    return OpenFile(new_path, Mode::ReadWrite);
+    // Unused
+    return nullptr;
 }
 
 VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_view new_path_) {
@@ -127,13 +131,13 @@ VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_
             file->Close();
         }
 
-        if (!FS::Exists(old_path) || FS::Exists(new_path) || FS::IsDirectory(old_path) ||
-            !FS::Rename(old_path, new_path)) {
+        if (!FS::RenameFile(old_path, new_path)) {
             return nullptr;
         }
 
         cache.erase(old_path);
-        if (file->Open(new_path, "r+b")) {
+        file->Open(new_path, FS::FileAccessMode::Read, FS::FileType::BinaryFile);
+        if (file->IsOpen()) {
             cache.insert_or_assign(new_path, std::move(file));
         } else {
             LOG_ERROR(Service_FS, "Failed to open path {} in order to re-cache it", new_path);
@@ -157,7 +161,7 @@ bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
         cache.erase(path);
     }
 
-    return FS::Delete(path);
+    return FS::RemoveFile(path);
 }
 
 VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, Mode perms) {
@@ -168,12 +172,8 @@ VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, Mode perms)
 
 VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, Mode perms) {
     const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
-    const auto path_fwd = FS::SanitizePath(path, FS::DirectorySeparator::ForwardSlash);
-    if (!FS::Exists(path)) {
-        FS::CreateFullPath(path_fwd);
-        if (!FS::CreateDir(path)) {
-            return nullptr;
-        }
+    if (!FS::CreateDirs(path)) {
+        return nullptr;
     }
     // Cannot use make_shared as RealVfsDirectory constructor is private
     return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
@@ -181,13 +181,8 @@ VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, Mode perms
 
 VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_,
                                             std::string_view new_path_) {
-    const auto old_path = FS::SanitizePath(old_path_, FS::DirectorySeparator::PlatformDefault);
-    const auto new_path = FS::SanitizePath(new_path_, FS::DirectorySeparator::PlatformDefault);
-    if (!FS::Exists(old_path) || FS::Exists(new_path) || !FS::IsDirectory(old_path)) {
-        return nullptr;
-    }
-    FS::CopyDir(old_path, new_path);
-    return OpenDirectory(new_path, Mode::ReadWrite);
+    // Unused
+    return nullptr;
 }
 
 VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_,
@@ -195,8 +190,7 @@ VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_,
     const auto old_path = FS::SanitizePath(old_path_, FS::DirectorySeparator::PlatformDefault);
     const auto new_path = FS::SanitizePath(new_path_, FS::DirectorySeparator::PlatformDefault);
 
-    if (!FS::Exists(old_path) || FS::Exists(new_path) || FS::IsDirectory(old_path) ||
-        !FS::Rename(old_path, new_path)) {
+    if (!FS::RenameDir(old_path, new_path)) {
         return nullptr;
     }
 
@@ -208,7 +202,7 @@ VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_,
 
         const auto file_old_path =
             FS::SanitizePath(kv.first, FS::DirectorySeparator::PlatformDefault);
-        auto file_new_path = FS::SanitizePath(new_path + DIR_SEP + kv.first.substr(old_path.size()),
+        auto file_new_path = FS::SanitizePath(new_path + '/' + kv.first.substr(old_path.size()),
                                               FS::DirectorySeparator::PlatformDefault);
         const auto& cached = cache[file_old_path];
 
@@ -218,7 +212,8 @@ VirtualDir RealVfsFilesystem::MoveDirectory(std::string_view old_path_,
 
         auto file = cached.lock();
         cache.erase(file_old_path);
-        if (file->Open(file_new_path, "r+b")) {
+        file->Open(file_new_path, FS::FileAccessMode::Read, FS::FileType::BinaryFile);
+        if (file->IsOpen()) {
             cache.insert_or_assign(std::move(file_new_path), std::move(file));
         } else {
             LOG_ERROR(Service_FS, "Failed to open path {} in order to re-cache it", file_new_path);
@@ -245,15 +240,13 @@ bool RealVfsFilesystem::DeleteDirectory(std::string_view path_) {
         cache.erase(kv.first);
     }
 
-    return FS::DeleteDirRecursively(path);
+    return FS::RemoveDirRecursively(path);
 }
 
 RealVfsFile::RealVfsFile(RealVfsFilesystem& base_, std::shared_ptr<FS::IOFile> backing_,
                          const std::string& path_, Mode perms_)
     : base(base_), backing(std::move(backing_)), path(path_), parent_path(FS::GetParentPath(path_)),
-      path_components(FS::SplitPathComponents(path_)),
-      parent_components(FS::SliceVector(path_components, 0, path_components.size() - 1)),
-      perms(perms_) {}
+      path_components(FS::SplitPathComponents(path_)), perms(perms_) {}
 
 RealVfsFile::~RealVfsFile() = default;
 
@@ -266,7 +259,7 @@ std::size_t RealVfsFile::GetSize() const {
 }
 
 bool RealVfsFile::Resize(std::size_t new_size) {
-    return backing->Resize(new_size);
+    return backing->SetSize(new_size);
 }
 
 VirtualDir RealVfsFile::GetContainingDirectory() const {
@@ -274,33 +267,33 @@ VirtualDir RealVfsFile::GetContainingDirectory() const {
 }
 
 bool RealVfsFile::IsWritable() const {
-    return True(perms & Mode::WriteAppend);
+    return True(perms & Mode::Write);
 }
 
 bool RealVfsFile::IsReadable() const {
-    return True(perms & Mode::ReadWrite);
+    return True(perms & Mode::Read);
 }
 
 std::size_t RealVfsFile::Read(u8* data, std::size_t length, std::size_t offset) const {
-    if (!backing->Seek(static_cast<s64>(offset), SEEK_SET)) {
+    if (!backing->Seek(static_cast<s64>(offset))) {
         return 0;
     }
-    return backing->ReadBytes(data, length);
+    return backing->ReadSpan(std::span{data, length});
 }
 
 std::size_t RealVfsFile::Write(const u8* data, std::size_t length, std::size_t offset) {
-    if (!backing->Seek(static_cast<s64>(offset), SEEK_SET)) {
+    if (!backing->Seek(static_cast<s64>(offset))) {
         return 0;
     }
-    return backing->WriteBytes(data, length);
+    return backing->WriteSpan(std::span{data, length});
 }
 
 bool RealVfsFile::Rename(std::string_view name) {
-    return base.MoveFile(path, parent_path + DIR_SEP + std::string(name)) != nullptr;
+    return base.MoveFile(path, parent_path + '/' + std::string(name)) != nullptr;
 }
 
-bool RealVfsFile::Close() {
-    return backing->Close();
+void RealVfsFile::Close() {
+    backing->Close();
 }
 
 // TODO(DarkLordZach): MSVC would not let me combine the following two functions using 'if
@@ -313,15 +306,16 @@ std::vector<VirtualFile> RealVfsDirectory::IterateEntries<RealVfsFile, VfsFile>(
     }
 
     std::vector<VirtualFile> out;
-    FS::ForeachDirectoryEntry(
-        nullptr, path,
-        [&out, this](u64* entries_out, const std::string& directory, const std::string& filename) {
-            const std::string full_path = directory + DIR_SEP + filename;
-            if (!FS::IsDirectory(full_path)) {
-                out.emplace_back(base.OpenFile(full_path, perms));
-            }
-            return true;
-        });
+
+    const FS::DirEntryCallable callback = [this, &out](const std::filesystem::path& full_path) {
+        const auto full_path_string = FS::PathToUTF8String(full_path);
+
+        out.emplace_back(base.OpenFile(full_path_string, perms));
+
+        return true;
+    };
+
+    FS::IterateDirEntries(path, callback, FS::DirEntryFilter::File);
 
     return out;
 }
@@ -333,42 +327,41 @@ std::vector<VirtualDir> RealVfsDirectory::IterateEntries<RealVfsDirectory, VfsDi
     }
 
     std::vector<VirtualDir> out;
-    FS::ForeachDirectoryEntry(
-        nullptr, path,
-        [&out, this](u64* entries_out, const std::string& directory, const std::string& filename) {
-            const std::string full_path = directory + DIR_SEP + filename;
-            if (FS::IsDirectory(full_path)) {
-                out.emplace_back(base.OpenDirectory(full_path, perms));
-            }
-            return true;
-        });
+
+    const FS::DirEntryCallable callback = [this, &out](const std::filesystem::path& full_path) {
+        const auto full_path_string = FS::PathToUTF8String(full_path);
+
+        out.emplace_back(base.OpenDirectory(full_path_string, perms));
+
+        return true;
+    };
+
+    FS::IterateDirEntries(path, callback, FS::DirEntryFilter::Directory);
 
     return out;
 }
 
 RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string& path_, Mode perms_)
     : base(base_), path(FS::RemoveTrailingSlash(path_)), parent_path(FS::GetParentPath(path)),
-      path_components(FS::SplitPathComponents(path)),
-      parent_components(FS::SliceVector(path_components, 0, path_components.size() - 1)),
-      perms(perms_) {
-    if (!FS::Exists(path) && True(perms & Mode::WriteAppend)) {
-        FS::CreateDir(path);
+      path_components(FS::SplitPathComponents(path)), perms(perms_) {
+    if (!FS::Exists(path) && True(perms & Mode::Write)) {
+        void(FS::CreateDirs(path));
     }
 }
 
 RealVfsDirectory::~RealVfsDirectory() = default;
 
 VirtualFile RealVfsDirectory::GetFileRelative(std::string_view relative_path) const {
-    const auto full_path = FS::SanitizePath(path + DIR_SEP + std::string(relative_path));
-    if (!FS::Exists(full_path) || FS::IsDirectory(full_path)) {
+    const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path));
+    if (!FS::Exists(full_path) || FS::IsDir(full_path)) {
         return nullptr;
     }
     return base.OpenFile(full_path, perms);
 }
 
 VirtualDir RealVfsDirectory::GetDirectoryRelative(std::string_view relative_path) const {
-    const auto full_path = FS::SanitizePath(path + DIR_SEP + std::string(relative_path));
-    if (!FS::Exists(full_path) || !FS::IsDirectory(full_path)) {
+    const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path));
+    if (!FS::Exists(full_path) || !FS::IsDir(full_path)) {
         return nullptr;
     }
     return base.OpenDirectory(full_path, perms);
@@ -383,17 +376,20 @@ VirtualDir RealVfsDirectory::GetSubdirectory(std::string_view name) const {
 }
 
 VirtualFile RealVfsDirectory::CreateFileRelative(std::string_view relative_path) {
-    const auto full_path = FS::SanitizePath(path + DIR_SEP + std::string(relative_path));
+    const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path));
+    if (!FS::CreateParentDirs(full_path)) {
+        return nullptr;
+    }
     return base.CreateFile(full_path, perms);
 }
 
 VirtualDir RealVfsDirectory::CreateDirectoryRelative(std::string_view relative_path) {
-    const auto full_path = FS::SanitizePath(path + DIR_SEP + std::string(relative_path));
+    const auto full_path = FS::SanitizePath(path + '/' + std::string(relative_path));
     return base.CreateDirectory(full_path, perms);
 }
 
 bool RealVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
-    const auto full_path = FS::SanitizePath(this->path + DIR_SEP + std::string(name));
+    const auto full_path = FS::SanitizePath(this->path + '/' + std::string(name));
     return base.DeleteDirectory(full_path);
 }
 
@@ -406,11 +402,11 @@ std::vector<VirtualDir> RealVfsDirectory::GetSubdirectories() const {
 }
 
 bool RealVfsDirectory::IsWritable() const {
-    return True(perms & Mode::WriteAppend);
+    return True(perms & Mode::Write);
 }
 
 bool RealVfsDirectory::IsReadable() const {
-    return True(perms & Mode::ReadWrite);
+    return True(perms & Mode::Read);
 }
 
 std::string RealVfsDirectory::GetName() const {
@@ -426,27 +422,27 @@ VirtualDir RealVfsDirectory::GetParentDirectory() const {
 }
 
 VirtualDir RealVfsDirectory::CreateSubdirectory(std::string_view name) {
-    const std::string subdir_path = (path + DIR_SEP).append(name);
+    const std::string subdir_path = (path + '/').append(name);
     return base.CreateDirectory(subdir_path, perms);
 }
 
 VirtualFile RealVfsDirectory::CreateFile(std::string_view name) {
-    const std::string file_path = (path + DIR_SEP).append(name);
+    const std::string file_path = (path + '/').append(name);
     return base.CreateFile(file_path, perms);
 }
 
 bool RealVfsDirectory::DeleteSubdirectory(std::string_view name) {
-    const std::string subdir_path = (path + DIR_SEP).append(name);
+    const std::string subdir_path = (path + '/').append(name);
     return base.DeleteDirectory(subdir_path);
 }
 
 bool RealVfsDirectory::DeleteFile(std::string_view name) {
-    const std::string file_path = (path + DIR_SEP).append(name);
+    const std::string file_path = (path + '/').append(name);
     return base.DeleteFile(file_path);
 }
 
 bool RealVfsDirectory::Rename(std::string_view name) {
-    const std::string new_name = (parent_path + DIR_SEP).append(name);
+    const std::string new_name = (parent_path + '/').append(name);
     return base.MoveFile(path, new_name) != nullptr;
 }
 
@@ -462,14 +458,17 @@ std::map<std::string, VfsEntryType, std::less<>> RealVfsDirectory::GetEntries()
     }
 
     std::map<std::string, VfsEntryType, std::less<>> out;
-    FS::ForeachDirectoryEntry(
-        nullptr, path,
-        [&out](u64* entries_out, const std::string& directory, const std::string& filename) {
-            const std::string full_path = directory + DIR_SEP + filename;
-            out.emplace(filename,
-                        FS::IsDirectory(full_path) ? VfsEntryType::Directory : VfsEntryType::File);
-            return true;
-        });
+
+    const FS::DirEntryCallable callback = [&out](const std::filesystem::path& full_path) {
+        const auto filename = FS::PathToUTF8String(full_path.filename());
+
+        out.insert_or_assign(filename,
+                             FS::IsDir(full_path) ? VfsEntryType::Directory : VfsEntryType::File);
+
+        return true;
+    };
+
+    FS::IterateDirEntries(path, callback);
 
     return out;
 }

src/core/file_sys/vfs_real.h

@@ -61,14 +61,13 @@ private:
     RealVfsFile(RealVfsFilesystem& base, std::shared_ptr<Common::FS::IOFile> backing,
                 const std::string& path, Mode perms = Mode::Read);
 
-    bool Close();
+    void Close();
 
     RealVfsFilesystem& base;
     std::shared_ptr<Common::FS::IOFile> backing;
     std::string path;
     std::string parent_path;
     std::vector<std::string> path_components;
-    std::vector<std::string> parent_components;
     Mode perms;
 };
 
@@ -110,7 +109,6 @@ private:
     std::string path;
     std::string parent_path;
     std::vector<std::string> path_components;
-    std::vector<std::string> parent_components;
     Mode perms;
 };
 

src/core/file_sys/xts_archive.cpp

@@ -11,7 +11,7 @@
 #include <mbedtls/md.h>
 #include <mbedtls/sha256.h>
 
-#include "common/file_util.h"
+#include "common/fs/path_util.h"
 #include "common/hex_util.h"
 #include "common/string_util.h"
 #include "core/crypto/aes_util.h"

src/core/frontend/input.h

@@ -27,6 +27,10 @@ struct AnalogProperties {
     float range;
     float threshold;
 };
+template <typename StatusType>
+struct InputCallback {
+    std::function<void(StatusType)> on_change;
+};
 
 /// An abstract class template for an input device (a button, an analog input, etc.).
 template <typename StatusType>
@@ -50,6 +54,17 @@ public:
                                [[maybe_unused]] f32 freq_high) const {
         return {};
     }
+    void SetCallback(InputCallback<StatusType> callback_) {
+        callback = std::move(callback_);
+    }
+    void TriggerOnChange() {
+        if (callback.on_change) {
+            callback.on_change(GetStatus());
+        }
+    }
+
+private:
+    InputCallback<StatusType> callback;
 };
 
 /// An abstract class template for a factory that can create input devices.

src/core/hle/kernel/hle_ipc.cpp

@@ -30,16 +30,38 @@
 
 namespace Kernel {
 
-SessionRequestHandler::SessionRequestHandler() = default;
+SessionRequestHandler::SessionRequestHandler(KernelCore& kernel_, const char* service_name_)
+    : kernel{kernel_}, service_thread{kernel.CreateServiceThread(service_name_)} {}
 
-SessionRequestHandler::~SessionRequestHandler() = default;
+SessionRequestHandler::~SessionRequestHandler() {
+    kernel.ReleaseServiceThread(service_thread);
+}
+
+SessionRequestManager::SessionRequestManager(KernelCore& kernel_) : kernel{kernel_} {}
+
+SessionRequestManager::~SessionRequestManager() = default;
+
+bool SessionRequestManager::HasSessionRequestHandler(const HLERequestContext& context) const {
+    if (IsDomain() && context.HasDomainMessageHeader()) {
+        const auto& message_header = context.GetDomainMessageHeader();
+        const auto object_id = message_header.object_id;
+
+        if (object_id > DomainHandlerCount()) {
+            LOG_CRITICAL(IPC, "object_id {} is too big!", object_id);
+            return false;
+        }
+        return DomainHandler(object_id - 1) != nullptr;
+    } else {
+        return session_handler != nullptr;
+    }
+}
 
 void SessionRequestHandler::ClientConnected(KServerSession* session) {
-    session->SetSessionHandler(shared_from_this());
+    session->ClientConnected(shared_from_this());
 }
 
 void SessionRequestHandler::ClientDisconnected(KServerSession* session) {
-    session->SetSessionHandler(nullptr);
+    session->ClientDisconnected();
 }
 
 HLERequestContext::HLERequestContext(KernelCore& kernel_, Core::Memory::Memory& memory_,
@@ -169,12 +191,12 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const KHandleTab
 
     if (command_header->IsCloseCommand()) {
         // Close does not populate the rest of the IPC header
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     std::copy_n(src_cmdbuf, IPC::COMMAND_BUFFER_LENGTH, cmd_buf.begin());
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_thread) {
@@ -216,7 +238,7 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_t
     memory.WriteBlock(owner_process, requesting_thread.GetTLSAddress(), cmd_buf.data(),
                       write_size * sizeof(u32));
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {

src/core/hle/kernel/hle_ipc.h

@@ -46,6 +46,7 @@ class KThread;
 class KReadableEvent;
 class KSession;
 class KWritableEvent;
+class ServiceThread;
 
 enum class ThreadWakeupReason;
 
@@ -56,7 +57,7 @@ enum class ThreadWakeupReason;
  */
 class SessionRequestHandler : public std::enable_shared_from_this<SessionRequestHandler> {
 public:
-    SessionRequestHandler();
+    SessionRequestHandler(KernelCore& kernel, const char* service_name_);
     virtual ~SessionRequestHandler();
 
     /**
@@ -83,6 +84,14 @@ public:
      * @param server_session ServerSession associated with the connection.
      */
     void ClientDisconnected(KServerSession* session);
+
+    std::weak_ptr<ServiceThread> GetServiceThread() const {
+        return service_thread;
+    }
+
+protected:
+    KernelCore& kernel;
+    std::weak_ptr<ServiceThread> service_thread;
 };
 
 using SessionRequestHandlerPtr = std::shared_ptr<SessionRequestHandler>;
@@ -94,7 +103,8 @@ using SessionRequestHandlerPtr = std::shared_ptr<SessionRequestHandler>;
  */
 class SessionRequestManager final {
 public:
-    SessionRequestManager() = default;
+    explicit SessionRequestManager(KernelCore& kernel);
+    ~SessionRequestManager();
 
     bool IsDomain() const {
         return is_domain;
@@ -142,10 +152,19 @@ public:
         session_handler = std::move(handler);
     }
 
+    std::weak_ptr<ServiceThread> GetServiceThread() const {
+        return session_handler->GetServiceThread();
+    }
+
+    bool HasSessionRequestHandler(const HLERequestContext& context) const;
+
 private:
     bool is_domain{};
     SessionRequestHandlerPtr session_handler;
     std::vector<SessionRequestHandlerPtr> domain_handlers;
+
+private:
+    KernelCore& kernel;
 };
 
 /**

src/core/hle/kernel/k_address_arbiter.cpp

@@ -97,7 +97,7 @@ ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
         while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
                (it->GetAddressArbiterKey() == addr)) {
             KThread* target_thread = std::addressof(*it);
-            target_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
+            target_thread->SetSyncedObject(nullptr, ResultSuccess);
 
             ASSERT(target_thread->IsWaitingForAddressArbiter());
             target_thread->Wakeup();
@@ -107,7 +107,7 @@ ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
             ++num_waiters;
         }
     }
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count) {
@@ -130,7 +130,7 @@ ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32
         while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
                (it->GetAddressArbiterKey() == addr)) {
             KThread* target_thread = std::addressof(*it);
-            target_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
+            target_thread->SetSyncedObject(nullptr, ResultSuccess);
 
             ASSERT(target_thread->IsWaitingForAddressArbiter());
             target_thread->Wakeup();
@@ -140,7 +140,7 @@ ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32
             ++num_waiters;
         }
     }
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count) {
@@ -198,7 +198,7 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
         while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
                (it->GetAddressArbiterKey() == addr)) {
             KThread* target_thread = std::addressof(*it);
-            target_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
+            target_thread->SetSyncedObject(nullptr, ResultSuccess);
 
             ASSERT(target_thread->IsWaitingForAddressArbiter());
             target_thread->Wakeup();
@@ -208,7 +208,7 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
             ++num_waiters;
         }
     }
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout) {

src/core/hle/kernel/k_address_arbiter.h

@@ -37,7 +37,7 @@ public:
             return SignalAndModifyByWaitingCountIfEqual(addr, value, count);
         }
         UNREACHABLE();
-        return RESULT_UNKNOWN;
+        return ResultUnknown;
     }
 
     [[nodiscard]] ResultCode WaitForAddress(VAddr addr, Svc::ArbitrationType type, s32 value,
@@ -51,7 +51,7 @@ public:
             return WaitIfEqual(addr, value, timeout);
         }
         UNREACHABLE();
-        return RESULT_UNKNOWN;
+        return ResultUnknown;
     }
 
 private:

src/core/hle/kernel/k_auto_object.h

@@ -7,10 +7,11 @@
 #include <atomic>
 #include <string>
 
+#include <boost/intrusive/rbtree.hpp>
+
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/intrusive_red_black_tree.h"
 #include "core/hle/kernel/k_class_token.h"
 
 namespace Kernel {
@@ -175,7 +176,7 @@ private:
 
 class KAutoObjectWithListContainer;
 
-class KAutoObjectWithList : public KAutoObject {
+class KAutoObjectWithList : public KAutoObject, public boost::intrusive::set_base_hook<> {
 public:
     explicit KAutoObjectWithList(KernelCore& kernel_) : KAutoObject(kernel_) {}
 
@@ -192,6 +193,10 @@ public:
         }
     }
 
+    friend bool operator<(const KAutoObjectWithList& left, const KAutoObjectWithList& right) {
+        return &left < &right;
+    }
+
 public:
     virtual u64 GetId() const {
         return reinterpret_cast<u64>(this);
@@ -203,8 +208,6 @@ public:
 
 private:
     friend class KAutoObjectWithListContainer;
-
-    Common::IntrusiveRedBlackTreeNode list_node;
 };
 
 template <typename T>

src/core/hle/kernel/k_auto_object_container.cpp

@@ -9,13 +9,13 @@ namespace Kernel {
 void KAutoObjectWithListContainer::Register(KAutoObjectWithList* obj) {
     KScopedLightLock lk(m_lock);
 
-    m_object_list.insert(*obj);
+    m_object_list.insert_unique(*obj);
 }
 
 void KAutoObjectWithListContainer::Unregister(KAutoObjectWithList* obj) {
     KScopedLightLock lk(m_lock);
 
-    m_object_list.erase(m_object_list.iterator_to(*obj));
+    m_object_list.erase(*obj);
 }
 
 size_t KAutoObjectWithListContainer::GetOwnedCount(KProcess* owner) {

src/core/hle/kernel/k_auto_object_container.h

@@ -6,6 +6,8 @@
 
 #include <atomic>
 
+#include <boost/intrusive/rbtree.hpp>
+
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -23,8 +25,7 @@ class KAutoObjectWithListContainer {
     YUZU_NON_MOVEABLE(KAutoObjectWithListContainer);
 
 public:
-    using ListType = Common::IntrusiveRedBlackTreeMemberTraits<
-        &KAutoObjectWithList::list_node>::TreeType<KAutoObjectWithList>;
+    using ListType = boost::intrusive::rbtree<KAutoObjectWithList>;
 
 public:
     class ListAccessor : public KScopedLightLock {

src/core/hle/kernel/k_class_token.cpp

@@ -84,50 +84,43 @@ static_assert(ClassToken<KTransferMemory> == ((0b10010001 << 8) | ClassToken<KAu
 // Ensure that the token hierarchy reflects the class hierarchy.
 
 // Base classes.
-static_assert(!std::is_final<KSynchronizationObject>::value &&
-              std::is_base_of<KAutoObject, KSynchronizationObject>::value);
-static_assert(!std::is_final<KReadableEvent>::value &&
-              std::is_base_of<KSynchronizationObject, KReadableEvent>::value);
+static_assert(!std::is_final_v<KSynchronizationObject> &&
+              std::is_base_of_v<KAutoObject, KSynchronizationObject>);
+static_assert(!std::is_final_v<KReadableEvent> &&
+              std::is_base_of_v<KSynchronizationObject, KReadableEvent>);
 
 // Final classes
-// static_assert(std::is_final<KInterruptEvent>::value &&
-//              std::is_base_of<KReadableEvent, KInterruptEvent>::value);
-// static_assert(std::is_final<KDebug>::value &&
-//              std::is_base_of<KSynchronizationObject, KDebug>::value);
-static_assert(std::is_final<KThread>::value &&
-              std::is_base_of<KSynchronizationObject, KThread>::value);
-static_assert(std::is_final<KServerPort>::value &&
-              std::is_base_of<KSynchronizationObject, KServerPort>::value);
-static_assert(std::is_final<KServerSession>::value &&
-              std::is_base_of<KSynchronizationObject, KServerSession>::value);
-static_assert(std::is_final<KClientPort>::value &&
-              std::is_base_of<KSynchronizationObject, KClientPort>::value);
-static_assert(std::is_final<KClientSession>::value &&
-              std::is_base_of<KAutoObject, KClientSession>::value);
-static_assert(std::is_final<KProcess>::value &&
-              std::is_base_of<KSynchronizationObject, KProcess>::value);
-static_assert(std::is_final<KResourceLimit>::value &&
-              std::is_base_of<KAutoObject, KResourceLimit>::value);
-// static_assert(std::is_final<KLightSession>::value &&
-//              std::is_base_of<KAutoObject, KLightSession>::value);
-static_assert(std::is_final<KPort>::value && std::is_base_of<KAutoObject, KPort>::value);
-static_assert(std::is_final<KSession>::value && std::is_base_of<KAutoObject, KSession>::value);
-static_assert(std::is_final<KSharedMemory>::value &&
-              std::is_base_of<KAutoObject, KSharedMemory>::value);
-static_assert(std::is_final<KEvent>::value && std::is_base_of<KAutoObject, KEvent>::value);
-static_assert(std::is_final<KWritableEvent>::value &&
-              std::is_base_of<KAutoObject, KWritableEvent>::value);
-// static_assert(std::is_final<KLightClientSession>::value &&
-//              std::is_base_of<KAutoObject, KLightClientSession>::value);
-// static_assert(std::is_final<KLightServerSession>::value &&
-//              std::is_base_of<KAutoObject, KLightServerSession>::value);
-static_assert(std::is_final<KTransferMemory>::value &&
-              std::is_base_of<KAutoObject, KTransferMemory>::value);
-// static_assert(std::is_final<KDeviceAddressSpace>::value &&
-//              std::is_base_of<KAutoObject, KDeviceAddressSpace>::value);
-// static_assert(std::is_final<KSessionRequest>::value &&
-//              std::is_base_of<KAutoObject, KSessionRequest>::value);
-// static_assert(std::is_final<KCodeMemory>::value &&
-//              std::is_base_of<KAutoObject, KCodeMemory>::value);
+// static_assert(std::is_final_v<KInterruptEvent> &&
+//              std::is_base_of_v<KReadableEvent, KInterruptEvent>);
+// static_assert(std::is_final_v<KDebug> &&
+//              std::is_base_of_v<KSynchronizationObject, KDebug>);
+static_assert(std::is_final_v<KThread> && std::is_base_of_v<KSynchronizationObject, KThread>);
+static_assert(std::is_final_v<KServerPort> &&
+              std::is_base_of_v<KSynchronizationObject, KServerPort>);
+static_assert(std::is_final_v<KServerSession> &&
+              std::is_base_of_v<KSynchronizationObject, KServerSession>);
+static_assert(std::is_final_v<KClientPort> &&
+              std::is_base_of_v<KSynchronizationObject, KClientPort>);
+static_assert(std::is_final_v<KClientSession> && std::is_base_of_v<KAutoObject, KClientSession>);
+static_assert(std::is_final_v<KProcess> && std::is_base_of_v<KSynchronizationObject, KProcess>);
+static_assert(std::is_final_v<KResourceLimit> && std::is_base_of_v<KAutoObject, KResourceLimit>);
+// static_assert(std::is_final_v<KLightSession> &&
+//              std::is_base_of_v<KAutoObject, KLightSession>);
+static_assert(std::is_final_v<KPort> && std::is_base_of_v<KAutoObject, KPort>);
+static_assert(std::is_final_v<KSession> && std::is_base_of_v<KAutoObject, KSession>);
+static_assert(std::is_final_v<KSharedMemory> && std::is_base_of_v<KAutoObject, KSharedMemory>);
+static_assert(std::is_final_v<KEvent> && std::is_base_of_v<KAutoObject, KEvent>);
+static_assert(std::is_final_v<KWritableEvent> && std::is_base_of_v<KAutoObject, KWritableEvent>);
+// static_assert(std::is_final_v<KLightClientSession> &&
+//              std::is_base_of_v<KAutoObject, KLightClientSession>);
+// static_assert(std::is_final_v<KLightServerSession> &&
+//              std::is_base_of_v<KAutoObject, KLightServerSession>);
+static_assert(std::is_final_v<KTransferMemory> && std::is_base_of_v<KAutoObject, KTransferMemory>);
+// static_assert(std::is_final_v<KDeviceAddressSpace> &&
+//              std::is_base_of_v<KAutoObject, KDeviceAddressSpace>);
+// static_assert(std::is_final_v<KSessionRequest> &&
+//              std::is_base_of_v<KAutoObject, KSessionRequest>);
+// static_assert(std::is_final_v<KCodeMemory> &&
+//              std::is_base_of_v<KAutoObject, KCodeMemory>);
 
 } // namespace Kernel

src/core/hle/kernel/k_client_port.cpp

@@ -16,11 +16,11 @@ namespace Kernel {
 KClientPort::KClientPort(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
 KClientPort::~KClientPort() = default;
 
-void KClientPort::Initialize(KPort* parent_, s32 max_sessions_, std::string&& name_) {
+void KClientPort::Initialize(KPort* parent_port_, s32 max_sessions_, std::string&& name_) {
     // Set member variables.
     num_sessions = 0;
     peak_sessions = 0;
-    parent = parent_;
+    parent = parent_port_;
     max_sessions = max_sessions_;
     name = std::move(name_);
 }
@@ -28,6 +28,9 @@ void KClientPort::Initialize(KPort* parent_, s32 max_sessions_, std::string&& na
 void KClientPort::OnSessionFinalized() {
     KScopedSchedulerLock sl{kernel};
 
+    // This might happen if a session was improperly used with this port.
+    ASSERT_MSG(num_sessions > 0, "num_sessions is invalid");
+
     const auto prev = num_sessions--;
     if (prev == max_sessions) {
         this->NotifyAvailable();
@@ -56,7 +59,8 @@ bool KClientPort::IsSignaled() const {
     return num_sessions < max_sessions;
 }
 
-ResultCode KClientPort::CreateSession(KClientSession** out) {
+ResultCode KClientPort::CreateSession(KClientSession** out,
+                                      std::shared_ptr<SessionRequestManager> session_manager) {
     // Reserve a new session from the resource limit.
     KScopedResourceReservation session_reservation(kernel.CurrentProcess()->GetResourceLimit(),
                                                    LimitableResource::Sessions);
@@ -65,7 +69,7 @@ ResultCode KClientPort::CreateSession(KClientSession** out) {
     // Update the session counts.
     {
         // Atomically increment the number of sessions.
-        s32 new_sessions;
+        s32 new_sessions{};
         {
             const auto max = max_sessions;
             auto cur_sessions = num_sessions.load(std::memory_order_acquire);
@@ -101,7 +105,7 @@ ResultCode KClientPort::CreateSession(KClientSession** out) {
     }
 
     // Initialize the session.
-    session->Initialize(this, parent->GetName());
+    session->Initialize(this, parent->GetName(), session_manager);
 
     // Commit the session reservation.
     session_reservation.Commit();
@@ -119,7 +123,7 @@ ResultCode KClientPort::CreateSession(KClientSession** out) {
     // We succeeded, so set the output.
     session_guard.Cancel();
     *out = std::addressof(session->GetClientSession());
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_client_port.h

@@ -16,13 +16,14 @@ namespace Kernel {
 class KClientSession;
 class KernelCore;
 class KPort;
+class SessionRequestManager;
 
 class KClientPort final : public KSynchronizationObject {
     KERNEL_AUTOOBJECT_TRAITS(KClientPort, KSynchronizationObject);
 
 public:
     explicit KClientPort(KernelCore& kernel_);
-    virtual ~KClientPort() override;
+    ~KClientPort() override;
 
     void Initialize(KPort* parent_, s32 max_sessions_, std::string&& name_);
     void OnSessionFinalized();
@@ -49,10 +50,11 @@ public:
     bool IsServerClosed() const;
 
     // Overridden virtual functions.
-    virtual void Destroy() override;
-    virtual bool IsSignaled() const override;
+    void Destroy() override;
+    bool IsSignaled() const override;
 
-    ResultCode CreateSession(KClientSession** out);
+    ResultCode CreateSession(KClientSession** out,
+                             std::shared_ptr<SessionRequestManager> session_manager = nullptr);
 
 private:
     std::atomic<s32> num_sessions{};

src/core/hle/kernel/k_client_session.h

@@ -34,15 +34,15 @@ class KClientSession final
 
 public:
     explicit KClientSession(KernelCore& kernel_);
-    virtual ~KClientSession();
+    ~KClientSession() override;
 
-    void Initialize(KSession* parent_, std::string&& name_) {
+    void Initialize(KSession* parent_session_, std::string&& name_) {
         // Set member variables.
-        parent = parent_;
+        parent = parent_session_;
         name = std::move(name_);
     }
 
-    virtual void Destroy() override;
+    void Destroy() override;
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
     KSession* GetParent() const {

src/core/hle/kernel/k_condition_variable.cpp

@@ -86,7 +86,7 @@ ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
                 next_value |= Svc::HandleWaitMask;
             }
 
-            next_owner_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
+            next_owner_thread->SetSyncedObject(nullptr, ResultSuccess);
             next_owner_thread->Wakeup();
         }
 
@@ -100,7 +100,7 @@ ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
         }
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 value) {
@@ -112,7 +112,7 @@ ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 val
         ASSERT(owner_thread.IsNull());
         {
             KScopedSchedulerLock sl(kernel);
-            cur_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
+            cur_thread->SetSyncedObject(nullptr, ResultSuccess);
 
             // Check if the thread should terminate.
             R_UNLESS(!cur_thread->IsTerminationRequested(), ResultTerminationRequested);
@@ -124,7 +124,7 @@ ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 val
                          ResultInvalidCurrentMemory);
 
                 // If the tag isn't the handle (with wait mask), we're done.
-                R_UNLESS(test_tag == (handle | Svc::HandleWaitMask), RESULT_SUCCESS);
+                R_UNLESS(test_tag == (handle | Svc::HandleWaitMask), ResultSuccess);
 
                 // Get the lock owner thread.
                 owner_thread =
@@ -181,7 +181,7 @@ KThread* KConditionVariable::SignalImpl(KThread* thread) {
     if (can_access) {
         if (prev_tag == Svc::InvalidHandle) {
             // If nobody held the lock previously, we're all good.
-            thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
+            thread->SetSyncedObject(nullptr, ResultSuccess);
             thread->Wakeup();
         } else {
             // Get the previous owner.
@@ -292,7 +292,7 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
                 }
 
                 // Wake up the next owner.
-                next_owner_thread->SetSyncedObject(nullptr, RESULT_SUCCESS);
+                next_owner_thread->SetSyncedObject(nullptr, ResultSuccess);
                 next_owner_thread->Wakeup();
             }
 

src/core/hle/kernel/k_event.h

@@ -20,23 +20,21 @@ class KEvent final : public KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObj
 
 public:
     explicit KEvent(KernelCore& kernel_);
-    virtual ~KEvent();
+    ~KEvent() override;
 
     void Initialize(std::string&& name);
 
-    virtual void Finalize() override;
+    void Finalize() override;
 
-    virtual bool IsInitialized() const override {
+    bool IsInitialized() const override {
         return initialized;
     }
 
-    virtual uintptr_t GetPostDestroyArgument() const override {
+    uintptr_t GetPostDestroyArgument() const override {
         return reinterpret_cast<uintptr_t>(owner);
     }
 
-    static void PostDestroy(uintptr_t arg);
-
-    virtual KProcess* GetOwner() const override {
+    KProcess* GetOwner() const override {
         return owner;
     }
 
@@ -48,6 +46,8 @@ public:
         return writable_event;
     }
 
+    static void PostDestroy(uintptr_t arg);
+
 private:
     KReadableEvent readable_event;
     KWritableEvent writable_event;

src/core/hle/kernel/k_handle_table.cpp

@@ -25,7 +25,7 @@ ResultCode KHandleTable::Finalize() {
         }
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 bool KHandleTable::Remove(Handle handle) {
@@ -79,7 +79,7 @@ ResultCode KHandleTable::Add(Handle* out_handle, KAutoObject* obj, u16 type) {
         *out_handle = EncodeHandle(static_cast<u16>(index), linear_id);
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KHandleTable::Reserve(Handle* out_handle) {
@@ -89,7 +89,7 @@ ResultCode KHandleTable::Reserve(Handle* out_handle) {
     R_UNLESS(m_count < m_table_size, ResultOutOfHandles);
 
     *out_handle = EncodeHandle(static_cast<u16>(this->AllocateEntry()), this->AllocateLinearId());
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 void KHandleTable::Unreserve(Handle handle) {

src/core/hle/kernel/k_handle_table.h

@@ -50,7 +50,7 @@ public:
             m_free_head_index = i;
         }
 
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     size_t GetTableSize() const {

src/core/hle/kernel/k_light_condition_variable.h

@@ -18,41 +18,58 @@ class KernelCore;
 
 class KLightConditionVariable {
 public:
-    explicit KLightConditionVariable(KernelCore& kernel_)
-        : thread_queue(kernel_), kernel(kernel_) {}
+    explicit KLightConditionVariable(KernelCore& kernel_) : kernel{kernel_} {}
 
-    void Wait(KLightLock* lock, s64 timeout = -1) {
-        WaitImpl(lock, timeout);
-        lock->Lock();
+    void Wait(KLightLock* lock, s64 timeout = -1, bool allow_terminating_thread = true) {
+        WaitImpl(lock, timeout, allow_terminating_thread);
     }
 
     void Broadcast() {
         KScopedSchedulerLock lk{kernel};
-        while (thread_queue.WakeupFrontThread() != nullptr) {
-            // We want to signal all threads, and so should continue waking up until there's nothing
-            // to wake.
+
+        // Signal all threads.
+        for (auto& thread : wait_list) {
+            thread.SetState(ThreadState::Runnable);
         }
     }
 
 private:
-    void WaitImpl(KLightLock* lock, s64 timeout) {
+    void WaitImpl(KLightLock* lock, s64 timeout, bool allow_terminating_thread) {
         KThread* owner = GetCurrentThreadPointer(kernel);
 
         // Sleep the thread.
         {
-            KScopedSchedulerLockAndSleep lk(kernel, owner, timeout);
-            lock->Unlock();
+            KScopedSchedulerLockAndSleep lk{kernel, owner, timeout};
 
-            if (!thread_queue.SleepThread(owner)) {
+            if (!allow_terminating_thread && owner->IsTerminationRequested()) {
                 lk.CancelSleep();
                 return;
             }
+
+            lock->Unlock();
+
+            // Set the thread as waiting.
+            GetCurrentThread(kernel).SetState(ThreadState::Waiting);
+
+            // Add the thread to the queue.
+            wait_list.push_back(GetCurrentThread(kernel));
+        }
+
+        // Remove the thread from the wait list.
+        {
+            KScopedSchedulerLock sl{kernel};
+
+            wait_list.erase(wait_list.iterator_to(GetCurrentThread(kernel)));
         }
 
         // Cancel the task that the sleep setup.
         kernel.TimeManager().UnscheduleTimeEvent(owner);
+
+        // Re-acquire the lock.
+        lock->Lock();
     }
-    KThreadQueue thread_queue;
+
     KernelCore& kernel;
+    KThread::WaiterList wait_list{};
 };
 } // namespace Kernel

src/core/hle/kernel/k_light_lock.cpp

@@ -59,11 +59,7 @@ void KLightLock::LockSlowPath(uintptr_t _owner, uintptr_t _cur_thread) {
         owner_thread->AddWaiter(cur_thread);
 
         // Set thread states.
-        if (cur_thread->GetState() == ThreadState::Runnable) {
-            cur_thread->SetState(ThreadState::Waiting);
-        } else {
-            KScheduler::SetSchedulerUpdateNeeded(kernel);
-        }
+        cur_thread->SetState(ThreadState::Waiting);
 
         if (owner_thread->IsSuspended()) {
             owner_thread->ContinueIfHasKernelWaiters();
@@ -73,10 +69,9 @@ void KLightLock::LockSlowPath(uintptr_t _owner, uintptr_t _cur_thread) {
     // We're no longer waiting on the lock owner.
     {
         KScopedSchedulerLock sl{kernel};
-        KThread* owner_thread = cur_thread->GetLockOwner();
-        if (owner_thread) {
+
+        if (KThread* owner_thread = cur_thread->GetLockOwner(); owner_thread != nullptr) {
             owner_thread->RemoveWaiter(cur_thread);
-            KScheduler::SetSchedulerUpdateNeeded(kernel);
         }
     }
 }
@@ -95,17 +90,13 @@ void KLightLock::UnlockSlowPath(uintptr_t _cur_thread) {
 
         // Pass the lock to the next owner.
         uintptr_t next_tag = 0;
-        if (next_owner) {
+        if (next_owner != nullptr) {
             next_tag = reinterpret_cast<uintptr_t>(next_owner);
             if (num_waiters > 1) {
                 next_tag |= 0x1;
             }
 
-            if (next_owner->GetState() == ThreadState::Waiting) {
-                next_owner->SetState(ThreadState::Runnable);
-            } else {
-                KScheduler::SetSchedulerUpdateNeeded(kernel);
-            }
+            next_owner->SetState(ThreadState::Runnable);
 
             if (next_owner->IsSuspended()) {
                 next_owner->ContinueIfHasKernelWaiters();

src/core/hle/kernel/k_memory_manager.cpp

@@ -86,7 +86,7 @@ ResultCode KMemoryManager::Allocate(KPageLinkedList& page_list, std::size_t num_
 
     // Early return if we're allocating no pages
     if (num_pages == 0) {
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     // Lock the pool that we're allocating from
@@ -146,14 +146,14 @@ ResultCode KMemoryManager::Allocate(KPageLinkedList& page_list, std::size_t num_
 
     // We succeeded!
     group_guard.Cancel();
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KMemoryManager::Free(KPageLinkedList& page_list, std::size_t num_pages, Pool pool,
                                 Direction dir) {
     // Early return if we're freeing no pages
     if (!num_pages) {
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     // Lock the pool that we're freeing from
@@ -170,7 +170,7 @@ ResultCode KMemoryManager::Free(KPageLinkedList& page_list, std::size_t num_page
         chosen_manager.Free(it.GetAddress(), min_num_pages);
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 std::size_t KMemoryManager::Impl::CalculateManagementOverheadSize(std::size_t region_size) {

src/core/hle/kernel/k_page_linked_list.h

@@ -71,7 +71,7 @@ public:
 
     ResultCode AddBlock(u64 address, u64 num_pages) {
         if (!num_pages) {
-            return RESULT_SUCCESS;
+            return ResultSuccess;
         }
         if (!nodes.empty()) {
             const auto node = nodes.back();
@@ -82,7 +82,7 @@ public:
             }
         }
         nodes.push_back({address, num_pages});
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
 private:

src/core/hle/kernel/k_page_table.cpp

@@ -292,7 +292,7 @@ ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemory
 
     block_manager->Update(addr, num_pages, state, perm);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
@@ -329,14 +329,14 @@ ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std:
                           KMemoryAttribute::Locked);
     block_manager->Update(dst_addr, num_pages, KMemoryState::AliasCode);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     if (!size) {
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     const std::size_t num_pages{size / PageSize};
@@ -360,7 +360,7 @@ ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, st
     block_manager->Update(src_addr, num_pages, KMemoryState::Normal,
                           KMemoryPermission::ReadAndWrite);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 void KPageTable::MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start, VAddr end) {
@@ -408,7 +408,7 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
     });
 
     if (mapped_size == size) {
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     const std::size_t remaining_size{size - mapped_size};
@@ -440,14 +440,14 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
                           KMemoryAttribute::None, KMemoryState::Normal,
                           KMemoryPermission::ReadAndWrite, KMemoryAttribute::None);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     const VAddr end_addr{addr + size};
-    ResultCode result{RESULT_SUCCESS};
+    ResultCode result{ResultSuccess};
     std::size_t mapped_size{};
 
     // Verify that the region can be unmapped
@@ -468,7 +468,7 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
     }
 
     if (!mapped_size) {
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     CASCADE_CODE(UnmapMemory(addr, size));
@@ -477,14 +477,14 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
     process->GetResourceLimit()->Release(LimitableResource::PhysicalMemory, mapped_size);
     physical_memory_usage -= mapped_size;
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::UnmapMemory(VAddr addr, std::size_t size) {
     std::lock_guard lock{page_table_lock};
 
     const VAddr end_addr{addr + size};
-    ResultCode result{RESULT_SUCCESS};
+    ResultCode result{ResultSuccess};
     KPageLinkedList page_linked_list;
 
     // Unmap each region within the range
@@ -513,7 +513,7 @@ ResultCode KPageTable::UnmapMemory(VAddr addr, std::size_t size) {
 
     block_manager->Update(addr, num_pages, KMemoryState::Free);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
@@ -552,7 +552,7 @@ ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     block_manager->Update(dst_addr, num_pages, KMemoryState::Stack,
                           KMemoryPermission::ReadAndWrite);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
@@ -594,7 +594,7 @@ ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     block_manager->Update(src_addr, num_pages, src_state, KMemoryPermission::ReadAndWrite);
     block_manager->Update(dst_addr, num_pages, KMemoryState::Free);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
@@ -616,7 +616,7 @@ ResultCode KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_l
         cur_addr += node.GetNumPages() * PageSize;
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
@@ -638,7 +638,7 @@ ResultCode KPageTable::MapPages(VAddr addr, KPageLinkedList& page_linked_list, K
 
     block_manager->Update(addr, num_pages, state, perm);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked_list) {
@@ -655,7 +655,7 @@ ResultCode KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked
         cur_addr += node.GetNumPages() * PageSize;
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list,
@@ -677,7 +677,7 @@ ResultCode KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list,
 
     block_manager->Update(addr, num_pages, state, KMemoryPermission::None);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size,
@@ -708,7 +708,7 @@ ResultCode KPageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size,
 
     // Return early if there is nothing to change
     if (state == prev_state && perm == prev_perm) {
-        return RESULT_SUCCESS;
+        return ResultSuccess;
     }
 
     if ((prev_perm & KMemoryPermission::Execute) != (perm & KMemoryPermission::Execute)) {
@@ -725,7 +725,7 @@ ResultCode KPageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size,
 
     block_manager->Update(addr, num_pages, state, perm);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 KMemoryInfo KPageTable::QueryInfoImpl(VAddr addr) {
@@ -758,7 +758,7 @@ ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemo
 
     block_manager->Update(addr, size / PageSize, state, perm, attribute | KMemoryAttribute::Locked);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
@@ -775,7 +775,7 @@ ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
 
     block_manager->Update(addr, size / PageSize, state, KMemoryPermission::ReadAndWrite);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask,
@@ -797,13 +797,13 @@ ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryA
 
     block_manager->Update(addr, size / PageSize, state, perm, attribute);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::SetHeapCapacity(std::size_t new_heap_capacity) {
     std::lock_guard lock{page_table_lock};
     heap_capacity = new_heap_capacity;
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultVal<VAddr> KPageTable::SetHeapSize(std::size_t size) {
@@ -911,7 +911,7 @@ ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
         },
         perm);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size) {
@@ -934,13 +934,13 @@ ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size)
         },
         perm);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::InitializeMemoryLayout(VAddr start, VAddr end) {
     block_manager = std::make_unique<KMemoryBlockManager>(start, end);
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 bool KPageTable::IsRegionMapped(VAddr address, u64 size) {
@@ -1006,7 +1006,7 @@ ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLin
         addr += size;
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
@@ -1033,7 +1033,7 @@ ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermiss
     default:
         UNREACHABLE();
     }
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 constexpr VAddr KPageTable::GetRegionAddress(KMemoryState state) const {
@@ -1164,7 +1164,7 @@ constexpr ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemo
         return ResultInvalidCurrentMemory;
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
@@ -1223,7 +1223,7 @@ ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermissi
         *out_attr = first_attr & static_cast<KMemoryAttribute>(~ignore_attr);
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_port.cpp

@@ -59,7 +59,7 @@ ResultCode KPort::EnqueueSession(KServerSession* session) {
     server.EnqueueSession(session);
     server.GetSessionRequestHandler()->ClientConnected(server.AcceptSession());
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_port.h

@@ -22,7 +22,7 @@ class KPort final : public KAutoObjectWithSlabHeapAndContainer<KPort, KAutoObjec
 
 public:
     explicit KPort(KernelCore& kernel_);
-    virtual ~KPort();
+    ~KPort() override;
 
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
@@ -59,7 +59,6 @@ private:
         ServerClosed = 3,
     };
 
-private:
     KServerPort server;
     KClientPort client;
     State state{State::Invalid};

src/core/hle/kernel/k_process.cpp

@@ -142,7 +142,7 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st
     // Open a reference to the resource limit.
     process->resource_limit->Open();
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 KResourceLimit* KProcess::GetResourceLimit() const {
@@ -201,17 +201,15 @@ bool KProcess::ReleaseUserException(KThread* thread) {
 
         // Remove waiter thread.
         s32 num_waiters{};
-        KThread* next = thread->RemoveWaiterByKey(
-            std::addressof(num_waiters),
-            reinterpret_cast<uintptr_t>(std::addressof(exception_thread)));
-        if (next != nullptr) {
-            if (next->GetState() == ThreadState::Waiting) {
-                next->SetState(ThreadState::Runnable);
-            } else {
-                KScheduler::SetSchedulerUpdateNeeded(kernel);
-            }
+        if (KThread* next = thread->RemoveWaiterByKey(
+                std::addressof(num_waiters),
+                reinterpret_cast<uintptr_t>(std::addressof(exception_thread)));
+            next != nullptr) {
+            next->SetState(ThreadState::Runnable);
         }
 
+        KScheduler::SetSchedulerUpdateNeeded(kernel);
+
         return true;
     } else {
         return false;
@@ -258,7 +256,7 @@ ResultCode KProcess::AddSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAdd
     // Open a reference to the shared memory.
     shmem->Open();
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 void KProcess::RemoveSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAddr address,
@@ -291,7 +289,7 @@ ResultCode KProcess::Reset() {
 
     // Clear signaled.
     is_signaled = false;
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
@@ -524,7 +522,7 @@ ResultCode KProcess::AllocateMainThreadStack(std::size_t stack_size) {
 
     main_thread_stack_top += main_thread_stack_size;
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_process.h

@@ -310,7 +310,7 @@ public:
      *
      * @param metadata The provided metadata to load process specific info from.
      *
-     * @returns RESULT_SUCCESS if all relevant metadata was able to be
+     * @returns ResultSuccess if all relevant metadata was able to be
      *          loaded and parsed. Otherwise, an error code is returned.
      */
     ResultCode LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size);
@@ -331,19 +331,19 @@ public:
 
     void LoadModule(CodeSet code_set, VAddr base_addr);
 
-    virtual bool IsInitialized() const override {
+    bool IsInitialized() const override {
         return is_initialized;
     }
 
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
-    virtual void Finalize();
+    void Finalize() override;
 
-    virtual u64 GetId() const override final {
+    u64 GetId() const override {
         return GetProcessID();
     }
 
-    virtual bool IsSignaled() const override;
+    bool IsSignaled() const override;
 
     void PinCurrentThread();
     void UnpinCurrentThread();

src/core/hle/kernel/k_readable_event.cpp

@@ -36,13 +36,13 @@ ResultCode KReadableEvent::Signal() {
         NotifyAvailable();
     }
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KReadableEvent::Clear() {
     Reset();
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 ResultCode KReadableEvent::Reset() {
@@ -53,7 +53,7 @@ ResultCode KReadableEvent::Reset() {
     }
 
     is_signaled = false;
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_readable_event.h

@@ -21,9 +21,9 @@ public:
     explicit KReadableEvent(KernelCore& kernel_);
     ~KReadableEvent() override;
 
-    void Initialize(KEvent* parent_, std::string&& name_) {
+    void Initialize(KEvent* parent_event_, std::string&& name_) {
         is_signaled = false;
-        parent = parent_;
+        parent = parent_event_;
         name = std::move(name_);
     }
 
@@ -31,8 +31,8 @@ public:
         return parent;
     }
 
-    virtual bool IsSignaled() const override;
-    virtual void Destroy() override;
+    bool IsSignaled() const override;
+    void Destroy() override;
 
     ResultCode Signal();
     ResultCode Clear();

src/core/hle/kernel/k_resource_limit.cpp

@@ -80,7 +80,7 @@ ResultCode KResourceLimit::SetLimitValue(LimitableResource which, s64 value) {
 
     limit_values[index] = value;
 
-    return RESULT_SUCCESS;
+    return ResultSuccess;
 }
 
 bool KResourceLimit::Reserve(LimitableResource which, s64 value) {
@@ -117,7 +117,7 @@ bool KResourceLimit::Reserve(LimitableResource which, s64 value, s64 timeout) {
         if (current_hints[index] + value <= limit_values[index] &&
             (timeout < 0 || core_timing->GetGlobalTimeNs().count() < timeout)) {
             waiter_count++;
-            cond_var.Wait(&lock, timeout);
+            cond_var.Wait(&lock, timeout, false);
             waiter_count--;
         } else {
             break;