externals: Update dynarmic to 5a91c94.

vm_manager: Add missing commas to string literal array elements in GetMemoryStateName()

.gitignore

@@ -11,6 +11,7 @@ src/common/scm_rev.cpp
 .idea/
 .vs/
 .vscode/
+CMakeLists.txt.user
 
 # *nix related
 # Common convention for backup or temporary files

.travis.yml

@@ -23,7 +23,7 @@ matrix:
     - os: osx
       env: NAME="macos build"
       sudo: false
-      osx_image: xcode9.2
+      osx_image: xcode9.3
       install: "./.travis/macos/deps.sh"
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"
@@ -42,3 +42,7 @@ notifications:
   webhooks:
     urls:
       - https://api.yuzu-emu.org/code/travis/notify
+
+cache:
+  directories:
+    - $HOME/.ccache

.travis/linux/build.sh

@@ -1,3 +1,3 @@
 #!/bin/bash -ex
 
-docker run -v $(pwd):/yuzu ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e CCACHE_DIR=/ccache -v $HOME/.ccache:/ccache -v $(pwd):/yuzu ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh

.travis/linux/docker.sh

@@ -1,16 +1,18 @@
 #!/bin/bash -ex
 
 apt-get update
-apt-get install -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev wget
-
-# Get a recent version of CMake
-wget https://cmake.org/files/v3.10/cmake-3.10.1-Linux-x86_64.sh
-sh cmake-3.10.1-Linux-x86_64.sh --exclude-subdir --prefix=/ --skip-license
+apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev wget cmake ninja-build ccache
 
 cd /yuzu
 
+export PATH=/usr/lib/ccache:$PATH
+ln -sf /usr/bin/ccache /usr/lib/ccache/cc
+ln -sf /usr/bin/ccache /usr/lib/ccache/c++
 mkdir build && cd build
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
-make -j4
+ccache --show-stats > ccache_before
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
+ninja
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

.travis/macos/build.sh

@@ -7,8 +7,12 @@ export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
 
 mkdir build && cd build
+export PATH=/usr/local/opt/ccache/libexec:$PATH
+ccache --show-stats > ccache_before
 cmake --version
 cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
 make -j4
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

.travis/macos/deps.sh

@@ -1,5 +1,5 @@
 #!/bin/sh -ex
 
 brew update
-brew install dylibbundler p7zip qt5 sdl2
+brew install dylibbundler p7zip qt5 sdl2 ccache
 brew outdated cmake || brew upgrade cmake

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -3,7 +3,9 @@ function(copy_yuzu_Qt5_deps target_dir)
     set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
     set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
+    set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(PLATFORMS ${DLL_DEST}platforms/)
+    set(STYLES ${DLL_DEST}styles/)
     windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
         icudt*.dll
         icuin*.dll
@@ -14,4 +16,5 @@ function(copy_yuzu_Qt5_deps target_dir)
         Qt5Widgets$<$<CONFIG:Debug>:d>.*
     )
     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
+    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
 endfunction(copy_yuzu_Qt5_deps)

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Reporting Issues
 
-**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our Discord server, [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
+**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
 
 If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.
 

README.md

@@ -7,7 +7,7 @@ yuzu is an experimental open-source emulator for the Nintendo Switch from the cr
 
 It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu does not run any commercial Switch games. yuzu can boot some games, to varying degrees of success, but does not implement any of the necessary GPU features to render 3D graphics.
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success, but does not implement any of the necessary GPU features to render 3D graphics.
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

appveyor.yml

@@ -116,6 +116,7 @@ after_build:
 
           mkdir $RELEASE_DIST
           mkdir $RELEASE_DIST/platforms
+          mkdir $RELEASE_DIST/styles
 
           # copy the compiled binaries and other release files to the release folder
           Get-ChildItem "$CMAKE_BINARY_DIR" -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
@@ -136,6 +137,9 @@ after_build:
           # copy the qt windows plugin dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/platforms/qwindows.dll" -force -destination "$RELEASE_DIST/platforms"
 
+          # copy the qt windows vista style dll to platforms
+          Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/styles/qwindowsvistastyle.dll" -force -destination "$RELEASE_DIST/styles"
+
           7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
           7z a $MINGW_SEVENZIP $RELEASE_DIST
         }

externals/cmake-modules/WindowsCopyFiles.cmake

@@ -1,4 +1,4 @@
-# Copyright 2016 Citra Emulator Project
+# Copyright 2018 Yuzu Emulator Project
 # Licensed under GPLv2 or any later version
 # Refer to the license.txt file included.
 
@@ -22,7 +22,7 @@ function(windows_copy_files TARGET SOURCE_DIR DEST_DIR)
     # cmake adds an extra check for command success which doesn't work too well with robocopy
     # so trick it into thinking the command was successful with the || cmd /c "exit /b 0"
     add_custom_command(TARGET ${TARGET} POST_BUILD
-        COMMAND if not exist ${DEST_DIR} mkdir ${DEST_DIR} 2> nul
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
         COMMAND robocopy ${SOURCE_DIR} ${DEST_DIR} ${ARGN} /NJH /NJS /NDL /NFL /NC /NS /NP || cmd /c "exit /b 0"
     )
-endfunction()
+endfunction()

src/common/CMakeLists.txt

@@ -31,10 +31,8 @@ add_library(common STATIC
     bit_set.h
     break_points.cpp
     break_points.h
-    chunk_file.h
     cityhash.cpp
     cityhash.h
-    code_block.h
     color.h
     common_funcs.h
     common_paths.h
@@ -42,7 +40,6 @@ add_library(common STATIC
     file_util.cpp
     file_util.h
     hash.h
-    linear_disk_cache.h
     logging/backend.cpp
     logging/backend.h
     logging/filter.cpp

src/common/assert.h

@@ -52,5 +52,5 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
 
-#define UNIMPLEMENTED() DEBUG_ASSERT_MSG(false, "Unimplemented code!")
+#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)

src/common/bit_field.h

@@ -192,11 +192,6 @@ private:
     static_assert(position < 8 * sizeof(T), "Invalid position");
     static_assert(bits <= 8 * sizeof(T), "Invalid number of bits");
     static_assert(bits > 0, "Invalid number of bits");
-    static_assert(std::is_pod<T>::value, "Invalid base type");
+    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable in a BitField");
 };
 #pragma pack()
-
-#if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER)
-static_assert(std::is_trivially_copyable<BitField<0, 1, unsigned>>::value,
-              "BitField must be trivially copyable");
-#endif

src/common/chunk_file.h

@@ -1,623 +0,0 @@
-// Copyright (C) 2003 Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0 or later versions.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#pragma once
-
-// Extremely simple serialization framework.
-
-// (mis)-features:
-// + Super fast
-// + Very simple
-// + Same code is used for serialization and deserializaition (in most cases)
-// - Zero backwards/forwards compatibility
-// - Serialization code for anything complex has to be manually written.
-
-#include <cstring>
-#include <deque>
-#include <list>
-#include <map>
-#include <set>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-
-template <class T>
-struct LinkedListItem : public T {
-    LinkedListItem<T>* next;
-};
-
-class PointerWrap;
-
-class PointerWrapSection {
-public:
-    PointerWrapSection(PointerWrap& p, int ver, const char* title)
-        : p_(p), ver_(ver), title_(title) {}
-    ~PointerWrapSection();
-
-    bool operator==(const int& v) const {
-        return ver_ == v;
-    }
-    bool operator!=(const int& v) const {
-        return ver_ != v;
-    }
-    bool operator<=(const int& v) const {
-        return ver_ <= v;
-    }
-    bool operator>=(const int& v) const {
-        return ver_ >= v;
-    }
-    bool operator<(const int& v) const {
-        return ver_ < v;
-    }
-    bool operator>(const int& v) const {
-        return ver_ > v;
-    }
-
-    operator bool() const {
-        return ver_ > 0;
-    }
-
-private:
-    PointerWrap& p_;
-    int ver_;
-    const char* title_;
-};
-
-// Wrapper class
-class PointerWrap {
-// This makes it a compile error if you forget to define DoState() on non-POD.
-// Which also can be a problem, for example struct tm is non-POD on linux, for whatever reason...
-#ifdef _MSC_VER
-    template <typename T, bool isPOD = std::is_pod<T>::value,
-              bool isPointer = std::is_pointer<T>::value>
-#else
-    template <typename T, bool isPOD = __is_pod(T), bool isPointer = std::is_pointer<T>::value>
-#endif
-    struct DoHelper {
-        static void DoArray(PointerWrap* p, T* x, int count) {
-            for (int i = 0; i < count; ++i)
-                p->Do(x[i]);
-        }
-
-        static void Do(PointerWrap* p, T& x) {
-            p->DoClass(x);
-        }
-    };
-
-    template <typename T>
-    struct DoHelper<T, true, false> {
-        static void DoArray(PointerWrap* p, T* x, int count) {
-            p->DoVoid((void*)x, sizeof(T) * count);
-        }
-
-        static void Do(PointerWrap* p, T& x) {
-            p->DoVoid((void*)&x, sizeof(x));
-        }
-    };
-
-public:
-    enum Mode {
-        MODE_READ = 1, // load
-        MODE_WRITE,    // save
-        MODE_MEASURE,  // calculate size
-        MODE_VERIFY,   // compare
-    };
-
-    enum Error {
-        ERROR_NONE = 0,
-        ERROR_WARNING = 1,
-        ERROR_FAILURE = 2,
-    };
-
-    u8** ptr;
-    Mode mode;
-    Error error;
-
-public:
-    PointerWrap(u8** ptr_, Mode mode_) : ptr(ptr_), mode(mode_), error(ERROR_NONE) {}
-    PointerWrap(unsigned char** ptr_, int mode_)
-        : ptr((u8**)ptr_), mode((Mode)mode_), error(ERROR_NONE) {}
-
-    PointerWrapSection Section(const char* title, int ver) {
-        return Section(title, ver, ver);
-    }
-
-    // The returned object can be compared against the version that was loaded.
-    // This can be used to support versions as old as minVer.
-    // Version = 0 means the section was not found.
-    PointerWrapSection Section(const char* title, int minVer, int ver) {
-        char marker[16] = {0};
-        int foundVersion = ver;
-
-        strncpy(marker, title, sizeof(marker));
-        if (!ExpectVoid(marker, sizeof(marker))) {
-            // Might be before we added name markers for safety.
-            if (foundVersion == 1 && ExpectVoid(&foundVersion, sizeof(foundVersion)))
-                DoMarker(title);
-            // Wasn't found, but maybe we can still load the state.
-            else
-                foundVersion = 0;
-        } else
-            Do(foundVersion);
-
-        if (error == ERROR_FAILURE || foundVersion < minVer || foundVersion > ver) {
-            LOG_ERROR(Common, "Savestate failure: wrong version %d found for %s", foundVersion,
-                      title);
-            SetError(ERROR_FAILURE);
-            return PointerWrapSection(*this, -1, title);
-        }
-        return PointerWrapSection(*this, foundVersion, title);
-    }
-
-    void SetMode(Mode mode_) {
-        mode = mode_;
-    }
-    Mode GetMode() const {
-        return mode;
-    }
-    u8** GetPPtr() {
-        return ptr;
-    }
-    void SetError(Error error_) {
-        if (error < error_)
-            error = error_;
-        if (error > ERROR_WARNING)
-            mode = PointerWrap::MODE_MEASURE;
-    }
-
-    bool ExpectVoid(void* data, int size) {
-        switch (mode) {
-        case MODE_READ:
-            if (memcmp(data, *ptr, size) != 0)
-                return false;
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, data, size);
-            break;
-        case MODE_MEASURE:
-            break; // MODE_MEASURE - don't need to do anything
-        case MODE_VERIFY:
-            for (int i = 0; i < size; i++) {
-                DEBUG_ASSERT_MSG(
-                    ((u8*)data)[i] == (*ptr)[i],
-                    "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n",
-                    ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i],
-                    &(*ptr)[i]);
-            }
-            break;
-        default:
-            break; // throw an error?
-        }
-        (*ptr) += size;
-        return true;
-    }
-
-    void DoVoid(void* data, int size) {
-        switch (mode) {
-        case MODE_READ:
-            memcpy(data, *ptr, size);
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, data, size);
-            break;
-        case MODE_MEASURE:
-            break; // MODE_MEASURE - don't need to do anything
-        case MODE_VERIFY:
-            for (int i = 0; i < size; i++) {
-                DEBUG_ASSERT_MSG(
-                    ((u8*)data)[i] == (*ptr)[i],
-                    "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n",
-                    ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i],
-                    &(*ptr)[i]);
-            }
-            break;
-        default:
-            break; // throw an error?
-        }
-        (*ptr) += size;
-    }
-
-    template <class K, class T>
-    void Do(std::map<K, T*>& x) {
-        if (mode == MODE_READ) {
-            for (auto it = x.begin(), end = x.end(); it != end; ++it) {
-                if (it->second != nullptr)
-                    delete it->second;
-            }
-        }
-        T* dv = nullptr;
-        DoMap(x, dv);
-    }
-
-    template <class K, class T>
-    void Do(std::map<K, T>& x) {
-        T dv = T();
-        DoMap(x, dv);
-    }
-
-    template <class K, class T>
-    void DoMap(std::map<K, T>& x, T& default_val) {
-        unsigned int number = (unsigned int)x.size();
-        Do(number);
-        switch (mode) {
-        case MODE_READ: {
-            x.clear();
-            while (number > 0) {
-                K first = K();
-                Do(first);
-                T second = default_val;
-                Do(second);
-                x[first] = second;
-                --number;
-            }
-        } break;
-        case MODE_WRITE:
-        case MODE_MEASURE:
-        case MODE_VERIFY: {
-            typename std::map<K, T>::iterator itr = x.begin();
-            while (number > 0) {
-                K first = itr->first;
-                Do(first);
-                Do(itr->second);
-                --number;
-                ++itr;
-            }
-        } break;
-        }
-    }
-
-    template <class K, class T>
-    void Do(std::multimap<K, T*>& x) {
-        if (mode == MODE_READ) {
-            for (auto it = x.begin(), end = x.end(); it != end; ++it) {
-                if (it->second != nullptr)
-                    delete it->second;
-            }
-        }
-        T* dv = nullptr;
-        DoMultimap(x, dv);
-    }
-
-    template <class K, class T>
-    void Do(std::multimap<K, T>& x) {
-        T dv = T();
-        DoMultimap(x, dv);
-    }
-
-    template <class K, class T>
-    void DoMultimap(std::multimap<K, T>& x, T& default_val) {
-        unsigned int number = (unsigned int)x.size();
-        Do(number);
-        switch (mode) {
-        case MODE_READ: {
-            x.clear();
-            while (number > 0) {
-                K first = K();
-                Do(first);
-                T second = default_val;
-                Do(second);
-                x.insert(std::make_pair(first, second));
-                --number;
-            }
-        } break;
-        case MODE_WRITE:
-        case MODE_MEASURE:
-        case MODE_VERIFY: {
-            typename std::multimap<K, T>::iterator itr = x.begin();
-            while (number > 0) {
-                Do(itr->first);
-                Do(itr->second);
-                --number;
-                ++itr;
-            }
-        } break;
-        }
-    }
-
-    // Store vectors.
-    template <class T>
-    void Do(std::vector<T*>& x) {
-        T* dv = nullptr;
-        DoVector(x, dv);
-    }
-
-    template <class T>
-    void Do(std::vector<T>& x) {
-        T dv = T();
-        DoVector(x, dv);
-    }
-
-    template <class T>
-    void DoPOD(std::vector<T>& x) {
-        T dv = T();
-        DoVectorPOD(x, dv);
-    }
-
-    template <class T>
-    void Do(std::vector<T>& x, T& default_val) {
-        DoVector(x, default_val);
-    }
-
-    template <class T>
-    void DoVector(std::vector<T>& x, T& default_val) {
-        u32 vec_size = (u32)x.size();
-        Do(vec_size);
-        x.resize(vec_size, default_val);
-        if (vec_size > 0)
-            DoArray(&x[0], vec_size);
-    }
-
-    template <class T>
-    void DoVectorPOD(std::vector<T>& x, T& default_val) {
-        u32 vec_size = (u32)x.size();
-        Do(vec_size);
-        x.resize(vec_size, default_val);
-        if (vec_size > 0)
-            DoArray(&x[0], vec_size);
-    }
-
-    // Store deques.
-    template <class T>
-    void Do(std::deque<T*>& x) {
-        T* dv = nullptr;
-        DoDeque(x, dv);
-    }
-
-    template <class T>
-    void Do(std::deque<T>& x) {
-        T dv = T();
-        DoDeque(x, dv);
-    }
-
-    template <class T>
-    void DoDeque(std::deque<T>& x, T& default_val) {
-        u32 deq_size = (u32)x.size();
-        Do(deq_size);
-        x.resize(deq_size, default_val);
-        u32 i;
-        for (i = 0; i < deq_size; i++)
-            Do(x[i]);
-    }
-
-    // Store STL lists.
-    template <class T>
-    void Do(std::list<T*>& x) {
-        T* dv = nullptr;
-        Do(x, dv);
-    }
-
-    template <class T>
-    void Do(std::list<T>& x) {
-        T dv = T();
-        DoList(x, dv);
-    }
-
-    template <class T>
-    void Do(std::list<T>& x, T& default_val) {
-        DoList(x, default_val);
-    }
-
-    template <class T>
-    void DoList(std::list<T>& x, T& default_val) {
-        u32 list_size = (u32)x.size();
-        Do(list_size);
-        x.resize(list_size, default_val);
-
-        typename std::list<T>::iterator itr, end;
-        for (itr = x.begin(), end = x.end(); itr != end; ++itr)
-            Do(*itr);
-    }
-
-    // Store STL sets.
-    template <class T>
-    void Do(std::set<T*>& x) {
-        if (mode == MODE_READ) {
-            for (auto it = x.begin(), end = x.end(); it != end; ++it) {
-                if (*it != nullptr)
-                    delete *it;
-            }
-        }
-        DoSet(x);
-    }
-
-    template <class T>
-    void Do(std::set<T>& x) {
-        DoSet(x);
-    }
-
-    template <class T>
-    void DoSet(std::set<T>& x) {
-        unsigned int number = (unsigned int)x.size();
-        Do(number);
-
-        switch (mode) {
-        case MODE_READ: {
-            x.clear();
-            while (number-- > 0) {
-                T it = T();
-                Do(it);
-                x.insert(it);
-            }
-        } break;
-        case MODE_WRITE:
-        case MODE_MEASURE:
-        case MODE_VERIFY: {
-            typename std::set<T>::iterator itr = x.begin();
-            while (number-- > 0)
-                Do(*itr++);
-        } break;
-
-        default:
-            LOG_ERROR(Common, "Savestate error: invalid mode %d.", mode);
-        }
-    }
-
-    // Store strings.
-    void Do(std::string& x) {
-        int stringLen = (int)x.length() + 1;
-        Do(stringLen);
-
-        switch (mode) {
-        case MODE_READ:
-            x = (char*)*ptr;
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, x.c_str(), stringLen);
-            break;
-        case MODE_MEASURE:
-            break;
-        case MODE_VERIFY:
-            DEBUG_ASSERT_MSG((x == (char*)*ptr),
-                             "Savestate verification failure: \"%s\" != \"%s\" (at %p).\n",
-                             x.c_str(), (char*)*ptr, ptr);
-            break;
-        }
-        (*ptr) += stringLen;
-    }
-
-    void Do(std::wstring& x) {
-        int stringLen = sizeof(wchar_t) * ((int)x.length() + 1);
-        Do(stringLen);
-
-        switch (mode) {
-        case MODE_READ:
-            x = (wchar_t*)*ptr;
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, x.c_str(), stringLen);
-            break;
-        case MODE_MEASURE:
-            break;
-        case MODE_VERIFY:
-            DEBUG_ASSERT_MSG((x == (wchar_t*)*ptr),
-                             "Savestate verification failure: \"%ls\" != \"%ls\" (at %p).\n",
-                             x.c_str(), (wchar_t*)*ptr, ptr);
-            break;
-        }
-        (*ptr) += stringLen;
-    }
-
-    template <class T>
-    void DoClass(T& x) {
-        x.DoState(*this);
-    }
-
-    template <class T>
-    void DoClass(T*& x) {
-        if (mode == MODE_READ) {
-            if (x != nullptr)
-                delete x;
-            x = new T();
-        }
-        x->DoState(*this);
-    }
-
-    template <class T>
-    void DoArray(T* x, int count) {
-        DoHelper<T>::DoArray(this, x, count);
-    }
-
-    template <class T>
-    void Do(T& x) {
-        DoHelper<T>::Do(this, x);
-    }
-
-    template <class T>
-    void DoPOD(T& x) {
-        DoHelper<T>::Do(this, x);
-    }
-
-    template <class T>
-    void DoPointer(T*& x, T* const base) {
-        // pointers can be more than 2^31 apart, but you're using this function wrong if you need
-        // that much range
-        s32 offset = x - base;
-        Do(offset);
-        if (mode == MODE_READ)
-            x = base + offset;
-    }
-
-    template <class T, LinkedListItem<T>* (*TNew)(), void (*TFree)(LinkedListItem<T>*),
-              void (*TDo)(PointerWrap&, T*)>
-    void DoLinkedList(LinkedListItem<T>*& list_start, LinkedListItem<T>** list_end = nullptr) {
-        LinkedListItem<T>* list_cur = list_start;
-        LinkedListItem<T>* prev = nullptr;
-
-        while (true) {
-            u8 shouldExist = (list_cur ? 1 : 0);
-            Do(shouldExist);
-            if (shouldExist == 1) {
-                LinkedListItem<T>* cur = list_cur ? list_cur : TNew();
-                TDo(*this, (T*)cur);
-                if (!list_cur) {
-                    if (mode == MODE_READ) {
-                        cur->next = nullptr;
-                        list_cur = cur;
-                        if (prev)
-                            prev->next = cur;
-                        else
-                            list_start = cur;
-                    } else {
-                        TFree(cur);
-                        continue;
-                    }
-                }
-            } else {
-                if (mode == MODE_READ) {
-                    if (prev)
-                        prev->next = nullptr;
-                    if (list_end)
-                        *list_end = prev;
-                    if (list_cur) {
-                        if (list_start == list_cur)
-                            list_start = nullptr;
-                        do {
-                            LinkedListItem<T>* next = list_cur->next;
-                            TFree(list_cur);
-                            list_cur = next;
-                        } while (list_cur);
-                    }
-                }
-                break;
-            }
-            prev = list_cur;
-            list_cur = list_cur->next;
-        }
-    }
-
-    void DoMarker(const char* prevName, u32 arbitraryNumber = 0x42) {
-        u32 cookie = arbitraryNumber;
-        Do(cookie);
-        if (mode == PointerWrap::MODE_READ && cookie != arbitraryNumber) {
-            LOG_ERROR(Common,
-                      "After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). "
-                      "Aborting savestate load...",
-                      prevName, cookie, cookie, arbitraryNumber, arbitraryNumber);
-            SetError(ERROR_FAILURE);
-        }
-    }
-};
-
-inline PointerWrapSection::~PointerWrapSection() {
-    if (ver_ > 0) {
-        p_.DoMarker(title_);
-    }
-}

src/common/code_block.h

@@ -1,85 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include "common/common_types.h"
-#include "common/memory_util.h"
-
-// Everything that needs to generate code should inherit from this.
-// You get memory management for free, plus, you can use all emitter functions without
-// having to prefix them with gen-> or something similar.
-// Example implementation:
-// class JIT : public CodeBlock<ARMXEmitter> {}
-template <class T>
-class CodeBlock : public T, NonCopyable {
-private:
-    // A privately used function to set the executable RAM space to something invalid.
-    // For debugging usefulness it should be used to set the RAM to a host specific breakpoint
-    // instruction
-    virtual void PoisonMemory() = 0;
-
-protected:
-    u8* region;
-    size_t region_size;
-
-public:
-    CodeBlock() : region(nullptr), region_size(0) {}
-    virtual ~CodeBlock() {
-        if (region)
-            FreeCodeSpace();
-    }
-
-    // Call this before you generate any code.
-    void AllocCodeSpace(int size) {
-        region_size = size;
-        region = (u8*)AllocateExecutableMemory(region_size);
-        T::SetCodePtr(region);
-    }
-
-    // Always clear code space with breakpoints, so that if someone accidentally executes
-    // uninitialized, it just breaks into the debugger.
-    void ClearCodeSpace() {
-        PoisonMemory();
-        ResetCodePtr();
-    }
-
-    // Call this when shutting down. Don't rely on the destructor, even though it'll do the job.
-    void FreeCodeSpace() {
-#ifdef __SYMBIAN32__
-        ResetExecutableMemory(region);
-#else
-        FreeMemoryPages(region, region_size);
-#endif
-        region = nullptr;
-        region_size = 0;
-    }
-
-    bool IsInSpace(const u8* ptr) {
-        return (ptr >= region) && (ptr < (region + region_size));
-    }
-
-    // Cannot currently be undone. Will write protect the entire code region.
-    // Start over if you need to change the code (call FreeCodeSpace(), AllocCodeSpace()).
-    void WriteProtect() {
-        WriteProtectMemory(region, region_size, true);
-    }
-
-    void ResetCodePtr() {
-        T::SetCodePtr(region);
-    }
-
-    size_t GetSpaceLeft() const {
-        return region_size - (T::GetCodePtr() - region);
-    }
-
-    u8* GetBasePtr() {
-        return region;
-    }
-
-    size_t GetOffset(const u8* ptr) const {
-        return ptr - region;
-    }
-};

src/common/common_funcs.h

@@ -4,13 +4,11 @@
 
 #pragma once
 
-#if !defined(ARCHITECTURE_x86_64) && !defined(_M_ARM)
+#if !defined(ARCHITECTURE_x86_64) && !defined(ARCHITECTURE_ARM)
 #include <cstdlib> // for exit
 #endif
 #include "common/common_types.h"
 
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
-
 /// Textually concatenates two tokens. The double-expansion is required by the C preprocessor.
 #define CONCAT2(x, y) DO_CONCAT2(x, y)
 #define DO_CONCAT2(x, y) x##y
@@ -32,7 +30,7 @@
 
 #ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
-#elif defined(_M_ARM)
+#elif defined(ARCHITECTURE_ARM)
 #define Crash() __asm__ __volatile__("trap")
 #else
 #define Crash() exit(1)
@@ -74,11 +72,6 @@ inline u64 _rotr64(u64 x, unsigned int shift) {
 
 #else // _MSC_VER
 
-#if (_MSC_VER < 1900)
-// Function Cross-Compatibility
-#define snprintf _snprintf
-#endif
-
 // Locale Cross-Compatibility
 #define locale_t _locale_t
 

src/common/common_paths.h

@@ -32,12 +32,15 @@
 #define SDMC_DIR "sdmc"
 #define NAND_DIR "nand"
 #define SYSDATA_DIR "sysdata"
+#define LOG_DIR "log"
 
 // Filenames
 // Files in the directory returned by GetUserPath(D_CONFIG_IDX)
 #define EMU_CONFIG "emu.ini"
 #define DEBUGGER_CONFIG "debugger.ini"
 #define LOGGER_CONFIG "logger.ini"
+// Files in the directory returned by GetUserPath(D_LOGS_IDX)
+#define LOG_FILE "yuzu_log.txt"
 
 // Sys files
 #define SHARED_FONT "shared_font.bin"

src/common/common_types.h

@@ -27,29 +27,23 @@
 #include <array>
 #include <cstdint>
 
-#ifdef _MSC_VER
-#ifndef __func__
-#define __func__ __FUNCTION__
-#endif
-#endif
+using u8 = std::uint8_t;   ///< 8-bit unsigned byte
+using u16 = std::uint16_t; ///< 16-bit unsigned short
+using u32 = std::uint32_t; ///< 32-bit unsigned word
+using u64 = std::uint64_t; ///< 64-bit unsigned int
 
-typedef std::uint8_t u8;   ///< 8-bit unsigned byte
-typedef std::uint16_t u16; ///< 16-bit unsigned short
-typedef std::uint32_t u32; ///< 32-bit unsigned word
-typedef std::uint64_t u64; ///< 64-bit unsigned int
+using s8 = std::int8_t;   ///< 8-bit signed byte
+using s16 = std::int16_t; ///< 16-bit signed short
+using s32 = std::int32_t; ///< 32-bit signed word
+using s64 = std::int64_t; ///< 64-bit signed int
 
-typedef std::int8_t s8;   ///< 8-bit signed byte
-typedef std::int16_t s16; ///< 16-bit signed short
-typedef std::int32_t s32; ///< 32-bit signed word
-typedef std::int64_t s64; ///< 64-bit signed int
-
-typedef float f32;  ///< 32-bit floating point
-typedef double f64; ///< 64-bit floating point
+using f32 = float;  ///< 32-bit floating point
+using f64 = double; ///< 64-bit floating point
 
 // TODO: It would be nice to eventually replace these with strong types that prevent accidental
 // conversion between each other.
-typedef u64 VAddr; ///< Represents a pointer in the userspace virtual address space.
-typedef u64 PAddr; ///< Represents a pointer in the ARM11 physical address space.
+using VAddr = u64; ///< Represents a pointer in the userspace virtual address space.
+using PAddr = u64; ///< Represents a pointer in the ARM11 physical address space.
 
 using u128 = std::array<std::uint64_t, 2>;
 static_assert(sizeof(u128) == 16, "u128 must be 128 bits wide");

src/common/file_util.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <sstream>
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_paths.h"
@@ -118,7 +119,7 @@ bool IsDirectory(const std::string& filename) {
 #endif
 
     if (result < 0) {
-        LOG_DEBUG(Common_Filesystem, "stat failed on %s: %s", filename.c_str(), GetLastErrorMsg());
+        LOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 
@@ -128,31 +129,29 @@ bool IsDirectory(const std::string& filename) {
 // Deletes a given filename, return true on success
 // Doesn't supports deleting a directory
 bool Delete(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "file %s", filename.c_str());
+    LOG_TRACE(Common_Filesystem, "file {}", filename);
 
     // Return true because we care about the file no
     // being there, not the actual delete.
     if (!Exists(filename)) {
-        LOG_DEBUG(Common_Filesystem, "%s does not exist", filename.c_str());
+        LOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
         return true;
     }
 
     // We can't delete a directory
     if (IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "Failed: %s is a directory", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
         return false;
     }
 
 #ifdef _WIN32
     if (!DeleteFileW(Common::UTF8ToUTF16W(filename).c_str())) {
-        LOG_ERROR(Common_Filesystem, "DeleteFile failed on %s: %s", filename.c_str(),
-                  GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 #else
     if (unlink(filename.c_str()) == -1) {
-        LOG_ERROR(Common_Filesystem, "unlink failed on %s: %s", filename.c_str(),
-                  GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 #endif
@@ -162,16 +161,16 @@ bool Delete(const std::string& filename) {
 
 // Returns true if successful, or path already exists.
 bool CreateDir(const std::string& path) {
-    LOG_TRACE(Common_Filesystem, "directory %s", path.c_str());
+    LOG_TRACE(Common_Filesystem, "directory {}", path);
 #ifdef _WIN32
     if (::CreateDirectoryW(Common::UTF8ToUTF16W(path).c_str(), nullptr))
         return true;
     DWORD error = GetLastError();
     if (error == ERROR_ALREADY_EXISTS) {
-        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on %s: already exists", path.c_str());
+        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
         return true;
     }
-    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on %s: %i", path.c_str(), error);
+    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
     return false;
 #else
     if (mkdir(path.c_str(), 0755) == 0)
@@ -180,11 +179,11 @@ bool CreateDir(const std::string& path) {
     int err = errno;
 
     if (err == EEXIST) {
-        LOG_DEBUG(Common_Filesystem, "mkdir failed on %s: already exists", path.c_str());
+        LOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
         return true;
     }
 
-    LOG_ERROR(Common_Filesystem, "mkdir failed on %s: %s", path.c_str(), strerror(err));
+    LOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
     return false;
 #endif
 }
@@ -192,10 +191,10 @@ bool CreateDir(const std::string& path) {
 // Creates the full path of fullPath returns true on success
 bool CreateFullPath(const std::string& fullPath) {
     int panicCounter = 100;
-    LOG_TRACE(Common_Filesystem, "path %s", fullPath.c_str());
+    LOG_TRACE(Common_Filesystem, "path {}", fullPath);
 
     if (FileUtil::Exists(fullPath)) {
-        LOG_DEBUG(Common_Filesystem, "path exists %s", fullPath.c_str());
+        LOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
         return true;
     }
 
@@ -227,11 +226,11 @@ bool CreateFullPath(const std::string& fullPath) {
 
 // Deletes a directory filename, returns true on success
 bool DeleteDir(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "directory %s", filename.c_str());
+    LOG_TRACE(Common_Filesystem, "directory {}", filename);
 
     // check if a directory
     if (!FileUtil::IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "Not a directory %s", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
         return false;
     }
 
@@ -242,14 +241,14 @@ bool DeleteDir(const std::string& filename) {
     if (rmdir(filename.c_str()) == 0)
         return true;
 #endif
-    LOG_ERROR(Common_Filesystem, "failed %s: %s", filename.c_str(), GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
 
     return false;
 }
 
 // renames file srcFilename to destFilename, returns true on success
 bool Rename(const std::string& srcFilename, const std::string& destFilename) {
-    LOG_TRACE(Common_Filesystem, "%s --> %s", srcFilename.c_str(), destFilename.c_str());
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
     if (_wrename(Common::UTF8ToUTF16W(srcFilename).c_str(),
                  Common::UTF8ToUTF16W(destFilename).c_str()) == 0)
@@ -258,20 +257,20 @@ bool Rename(const std::string& srcFilename, const std::string& destFilename) {
     if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
         return true;
 #endif
-    LOG_ERROR(Common_Filesystem, "failed %s --> %s: %s", srcFilename.c_str(), destFilename.c_str(),
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
               GetLastErrorMsg());
     return false;
 }
 
 // copies file srcFilename to destFilename, returns true on success
 bool Copy(const std::string& srcFilename, const std::string& destFilename) {
-    LOG_TRACE(Common_Filesystem, "%s --> %s", srcFilename.c_str(), destFilename.c_str());
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
     if (CopyFileW(Common::UTF8ToUTF16W(srcFilename).c_str(),
                   Common::UTF8ToUTF16W(destFilename).c_str(), FALSE))
         return true;
 
-    LOG_ERROR(Common_Filesystem, "failed %s --> %s: %s", srcFilename.c_str(), destFilename.c_str(),
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
               GetLastErrorMsg());
     return false;
 #else
@@ -284,8 +283,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     // Open input file
     FILE* input = fopen(srcFilename.c_str(), "rb");
     if (!input) {
-        LOG_ERROR(Common_Filesystem, "opening input failed %s --> %s: %s", srcFilename.c_str(),
-                  destFilename.c_str(), GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
+                  destFilename, GetLastErrorMsg());
         return false;
     }
 
@@ -293,8 +292,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     FILE* output = fopen(destFilename.c_str(), "wb");
     if (!output) {
         fclose(input);
-        LOG_ERROR(Common_Filesystem, "opening output failed %s --> %s: %s", srcFilename.c_str(),
-                  destFilename.c_str(), GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
+                  destFilename, GetLastErrorMsg());
         return false;
     }
 
@@ -304,8 +303,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
         size_t rnum = fread(buffer, sizeof(char), BSIZE, input);
         if (rnum != BSIZE) {
             if (ferror(input) != 0) {
-                LOG_ERROR(Common_Filesystem, "failed reading from source, %s --> %s: %s",
-                          srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
+                LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
+                          srcFilename, destFilename, GetLastErrorMsg());
                 goto bail;
             }
         }
@@ -313,8 +312,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
         // write output
         size_t wnum = fwrite(buffer, sizeof(char), rnum, output);
         if (wnum != rnum) {
-            LOG_ERROR(Common_Filesystem, "failed writing to output, %s --> %s: %s",
-                      srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
+            LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
+                      destFilename, GetLastErrorMsg());
             goto bail;
         }
     }
@@ -334,12 +333,12 @@ bail:
 // Returns the size of filename (64bit)
 u64 GetSize(const std::string& filename) {
     if (!Exists(filename)) {
-        LOG_ERROR(Common_Filesystem, "failed %s: No such file", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
         return 0;
     }
 
     if (IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "failed %s: is a directory", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
         return 0;
     }
 
@@ -350,11 +349,11 @@ u64 GetSize(const std::string& filename) {
     if (stat(filename.c_str(), &buf) == 0)
 #endif
     {
-        LOG_TRACE(Common_Filesystem, "%s: %lld", filename.c_str(), (long long)buf.st_size);
+        LOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
         return buf.st_size;
     }
 
-    LOG_ERROR(Common_Filesystem, "Stat failed %s: %s", filename.c_str(), GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
     return 0;
 }
 
@@ -362,7 +361,7 @@ u64 GetSize(const std::string& filename) {
 u64 GetSize(const int fd) {
     struct stat buf;
     if (fstat(fd, &buf) != 0) {
-        LOG_ERROR(Common_Filesystem, "GetSize: stat failed %i: %s", fd, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
         return 0;
     }
     return buf.st_size;
@@ -373,12 +372,12 @@ u64 GetSize(FILE* f) {
     // can't use off_t here because it can be 32-bit
     u64 pos = ftello(f);
     if (fseeko(f, 0, SEEK_END) != 0) {
-        LOG_ERROR(Common_Filesystem, "GetSize: seek failed %p: %s", f, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
         return 0;
     }
     u64 size = ftello(f);
     if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0)) {
-        LOG_ERROR(Common_Filesystem, "GetSize: seek failed %p: %s", f, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
         return 0;
     }
     return size;
@@ -386,10 +385,10 @@ u64 GetSize(FILE* f) {
 
 // creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "%s", filename.c_str());
+    LOG_TRACE(Common_Filesystem, "{}", filename);
 
-    if (!FileUtil::IOFile(filename, "wb")) {
-        LOG_ERROR(Common_Filesystem, "failed %s: %s", filename.c_str(), GetLastErrorMsg());
+    if (!FileUtil::IOFile(filename, "wb").IsOpen()) {
+        LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 
@@ -398,7 +397,7 @@ bool CreateEmptyFile(const std::string& filename) {
 
 bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback) {
-    LOG_TRACE(Common_Filesystem, "directory %s", directory.c_str());
+    LOG_TRACE(Common_Filesystem, "directory {}", directory);
 
     // How many files + directories we found
     unsigned found_entries = 0;
@@ -556,7 +555,7 @@ std::string GetCurrentDir() {
     char* dir;
     if (!(dir = getcwd(nullptr, 0))) {
 #endif
-        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: %s", GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
         return nullptr;
     }
 #ifdef _WIN32
@@ -653,12 +652,12 @@ static const std::string GetUserDirectory(const std::string& envvar) {
         else if (envvar == "XDG_CACHE_HOME")
             subdirectory = DIR_SEP ".cache";
         else
-            ASSERT_MSG(false, "Unknown XDG variable %s.", envvar.c_str());
+            ASSERT_MSG(false, "Unknown XDG variable {}.", envvar);
         user_dir = GetHomeDirectory() + subdirectory;
     }
 
-    ASSERT_MSG(!user_dir.empty(), "User directory %s musn’t be empty.", envvar.c_str());
-    ASSERT_MSG(user_dir[0] == '/', "User directory %s must be absolute.", envvar.c_str());
+    ASSERT_MSG(!user_dir.empty(), "User directory {} mustn’t be empty.", envvar);
+    ASSERT_MSG(user_dir[0] == '/', "User directory {} must be absolute.", envvar);
 
     return user_dir;
 }
@@ -676,11 +675,11 @@ std::string GetSysDirectory() {
 #endif
     sysDir += DIR_SEP;
 
-    LOG_DEBUG(Common_Filesystem, "Setting to %s:", sysDir.c_str());
+    LOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
     return sysDir;
 }
 
-// Returns a string with a Citra data dir or file in the user's home
+// Returns a string with a yuzu data dir or file in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
 const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath) {
     static std::string paths[NUM_PATH_INDICES];
@@ -715,11 +714,13 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string& new
         paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
         paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
         paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;
+        // TODO: Put the logs in a better location for each OS
+        paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOG_DIR DIR_SEP;
     }
 
     if (!newPath.empty()) {
         if (!FileUtil::IsDirectory(newPath)) {
-            LOG_ERROR(Common_Filesystem, "Invalid path specified %s", newPath.c_str());
+            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", newPath);
             return paths[DirIDX];
         } else {
             paths[DirIDX] = newPath;
@@ -750,7 +751,7 @@ size_t WriteStringToFile(bool text_file, const std::string& str, const char* fil
 size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
     IOFile file(filename, text_file ? "r" : "rb");
 
-    if (!file)
+    if (!file.IsOpen())
         return false;
 
     str.resize(static_cast<u32>(file.GetSize()));
@@ -799,49 +800,117 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
     }
 }
 
+std::vector<std::string> SplitPathComponents(const std::string& filename) {
+    auto copy(filename);
+    std::replace(copy.begin(), copy.end(), '\\', '/');
+    std::vector<std::string> out;
+
+    std::stringstream stream(filename);
+    std::string item;
+    while (std::getline(stream, item, '/'))
+        out.push_back(std::move(item));
+
+    return out;
+}
+
+std::string GetParentPath(const std::string& path) {
+    auto out = path;
+    const auto name_bck_index = out.find_last_of('\\');
+    const auto name_fwd_index = out.find_last_of('/');
+    size_t name_index;
+    if (name_bck_index == std::string::npos || name_fwd_index == std::string::npos)
+        name_index = std::min<size_t>(name_bck_index, name_fwd_index);
+    else
+        name_index = std::max<size_t>(name_bck_index, name_fwd_index);
+
+    return out.erase(name_index);
+}
+
+std::string GetPathWithoutTop(std::string path) {
+    if (path.empty())
+        return "";
+    while (path[0] == '\\' || path[0] == '/') {
+        path = path.substr(1);
+        if (path.empty())
+            return "";
+    }
+    const auto name_bck_index = path.find_first_of('\\');
+    const auto name_fwd_index = path.find_first_of('/');
+    return path.substr(std::min<size_t>(name_bck_index, name_fwd_index) + 1);
+    return path.substr(std::min<size_t>(name_bck_index, name_fwd_index) + 1);
+}
+
+std::string GetFilename(std::string path) {
+    std::replace(path.begin(), path.end(), '\\', '/');
+    auto name_index = path.find_last_of('/');
+    if (name_index == std::string::npos)
+        return "";
+    return path.substr(name_index + 1);
+}
+
+std::string GetExtensionFromFilename(const std::string& name) {
+    size_t index = name.find_last_of('.');
+    if (index == std::string::npos)
+        return "";
+
+    return name.substr(index + 1);
+}
+
+std::string RemoveTrailingSlash(const std::string& path) {
+    if (path.empty())
+        return path;
+    if (path.back() == '\\' || path.back() == '/')
+        return path.substr(0, path.size() - 1);
+
+    return path;
+}
+
 IOFile::IOFile() {}
 
-IOFile::IOFile(const std::string& filename, const char openmode[]) {
-    Open(filename, openmode);
+IOFile::IOFile(const std::string& filename, const char openmode[], int flags) {
+    Open(filename, openmode, flags);
 }
 
 IOFile::~IOFile() {
     Close();
 }
 
-IOFile::IOFile(IOFile&& other) {
+IOFile::IOFile(IOFile&& other) noexcept {
     Swap(other);
 }
 
-IOFile& IOFile::operator=(IOFile&& other) {
+IOFile& IOFile::operator=(IOFile&& other) noexcept {
     Swap(other);
     return *this;
 }
 
-void IOFile::Swap(IOFile& other) {
+void IOFile::Swap(IOFile& other) noexcept {
     std::swap(m_file, other.m_file);
-    std::swap(m_good, other.m_good);
 }
 
-bool IOFile::Open(const std::string& filename, const char openmode[]) {
+bool IOFile::Open(const std::string& filename, const char openmode[], int flags) {
     Close();
 #ifdef _WIN32
-    _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
-              Common::UTF8ToUTF16W(openmode).c_str());
+    if (flags != 0) {
+        m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
+                          Common::UTF8ToUTF16W(openmode).c_str(), flags);
+    } else {
+        _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+                  Common::UTF8ToUTF16W(openmode).c_str());
+    }
 #else
     m_file = fopen(filename.c_str(), openmode);
 #endif
 
-    m_good = IsOpen();
-    return m_good;
+    return IsOpen();
 }
 
 bool IOFile::Close() {
     if (!IsOpen() || 0 != std::fclose(m_file))
-        m_good = false;
+        return false;
 
     m_file = nullptr;
-    return m_good;
+    return true;
 }
 
 u64 IOFile::GetSize() const {
@@ -851,11 +920,8 @@ u64 IOFile::GetSize() const {
     return 0;
 }
 
-bool IOFile::Seek(s64 off, int origin) {
-    if (!IsOpen() || 0 != fseeko(m_file, off, origin))
-        m_good = false;
-
-    return m_good;
+bool IOFile::Seek(s64 off, int origin) const {
+    return IsOpen() && 0 == fseeko(m_file, off, origin);
 }
 
 u64 IOFile::Tell() const {
@@ -866,26 +932,20 @@ u64 IOFile::Tell() const {
 }
 
 bool IOFile::Flush() {
-    if (!IsOpen() || 0 != std::fflush(m_file))
-        m_good = false;
-
-    return m_good;
+    return IsOpen() && 0 == std::fflush(m_file);
 }
 
 bool IOFile::Resize(u64 size) {
-    if (!IsOpen() || 0 !=
+    return IsOpen() && 0 ==
 #ifdef _WIN32
-                         // ector: _chsize sucks, not 64-bit safe
-                         // F|RES: changed to _chsize_s. i think it is 64-bit safe
-                         _chsize_s(_fileno(m_file), size)
+                           // ector: _chsize sucks, not 64-bit safe
+                           // F|RES: changed to _chsize_s. i think it is 64-bit safe
+                           _chsize_s(_fileno(m_file), size)
 #else
-                         // TODO: handle 64bit and growing
-                         ftruncate(fileno(m_file), size)
+                           // TODO: handle 64bit and growing
+                           ftruncate(fileno(m_file), size)
 #endif
-    )
-        m_good = false;
-
-    return m_good;
+        ;
 }
 
 } // namespace FileUtil

src/common/file_util.h

@@ -150,71 +150,84 @@ size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
 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" }
+std::vector<std::string> SplitPathComponents(const std::string& filename);
+
+// Gets all of the text up to the last '/' or '\' in the path.
+std::string GetParentPath(const std::string& path);
+
+// Gets all of the text after the first '/' or '\' in the path.
+std::string GetPathWithoutTop(std::string path);
+
+// Gets the filename of the path
+std::string GetFilename(std::string path);
+
+// Gets the extension of the filename
+std::string GetExtensionFromFilename(const std::string& name);
+
+// Removes the final '/' or '\' if one exists
+std::string RemoveTrailingSlash(const std::string& path);
+
+// Creates a new vector containing indices [first, last) from the original.
+template <typename T>
+std::vector<T> SliceVector(const std::vector<T>& vector, size_t first, size_t last) {
+    if (first >= last)
+        return {};
+    last = std::min<size_t>(last, vector.size());
+    return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
+}
+
 // 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();
-    IOFile(const std::string& filename, const char openmode[]);
+    // 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);
-    IOFile& operator=(IOFile&& other);
+    IOFile(IOFile&& other) noexcept;
+    IOFile& operator=(IOFile&& other) noexcept;
 
-    void Swap(IOFile& other);
+    void Swap(IOFile& other) noexcept;
 
-    bool Open(const std::string& filename, const char openmode[]);
+    bool Open(const std::string& filename, const char openmode[], int flags = 0);
     bool Close();
 
     template <typename T>
-    size_t ReadArray(T* data, size_t length) {
-        static_assert(std::is_standard_layout<T>(),
-                      "Given array does not consist of standard layout objects");
-#if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER)
+    size_t ReadArray(T* data, size_t length) const {
         static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
-#endif
 
-        if (!IsOpen()) {
-            m_good = false;
+        if (!IsOpen())
             return -1;
-        }
 
-        size_t items_read = std::fread(data, sizeof(T), length, m_file);
-        if (items_read != length)
-            m_good = false;
-
-        return items_read;
+        return std::fread(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
     size_t WriteArray(const T* data, size_t length) {
-        static_assert(std::is_standard_layout<T>(),
-                      "Given array does not consist of standard layout objects");
-#if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER)
         static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
-#endif
-
-        if (!IsOpen()) {
-            m_good = false;
+        if (!IsOpen())
             return -1;
-        }
-
-        size_t items_written = std::fwrite(data, sizeof(T), length, m_file);
-        if (items_written != length)
-            m_good = false;
-
-        return items_written;
+        return std::fwrite(data, sizeof(T), length, m_file);
     }
 
-    size_t ReadBytes(void* data, size_t length) {
+    template <typename T>
+    size_t ReadBytes(T* data, size_t length) const {
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
 
-    size_t WriteBytes(const void* data, size_t length) {
+    template <typename T>
+    size_t WriteBytes(const T* data, size_t length) {
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return WriteArray(reinterpret_cast<const char*>(data), length);
     }
 
@@ -224,19 +237,15 @@ public:
         return WriteArray(&object, 1);
     }
 
+    size_t WriteString(const std::string& str) {
+        return WriteArray(str.c_str(), str.length());
+    }
+
     bool IsOpen() const {
         return nullptr != m_file;
     }
 
-    // m_good is set to false when a read, write or other function fails
-    bool IsGood() const {
-        return m_good;
-    }
-    explicit operator bool() const {
-        return IsGood();
-    }
-
-    bool Seek(s64 off, int origin);
+    bool Seek(s64 off, int origin) const;
     u64 Tell() const;
     u64 GetSize() const;
     bool Resize(u64 size);
@@ -244,13 +253,11 @@ public:
 
     // clear error state
     void Clear() {
-        m_good = true;
         std::clearerr(m_file);
     }
 
 private:
     std::FILE* m_file = nullptr;
-    bool m_good = true;
 };
 
 } // namespace FileUtil

src/common/linear_disk_cache.h

@@ -1,167 +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 <fstream>
-#include "common/common_types.h"
-
-// defined in Version.cpp
-extern const char* scm_rev_git_str;
-
-// On disk format:
-// header{
-// u32 'DCAC';
-// u32 version;  // svn_rev
-// u16 sizeof(key_type);
-// u16 sizeof(value_type);
-//}
-
-// key_value_pair{
-// u32 value_size;
-// key_type   key;
-// value_type[value_size]   value;
-//}
-
-template <typename K, typename V>
-class LinearDiskCacheReader {
-public:
-    virtual void Read(const K& key, const V* value, u32 value_size) = 0;
-};
-
-// Dead simple unsorted key-value store with append functionality.
-// No random read functionality, all reading is done in OpenAndRead.
-// Keys and values can contain any characters, including \0.
-//
-// Suitable for caching generated shader bytecode between executions.
-// Not tuned for extreme performance but should be reasonably fast.
-// Does not support keys or values larger than 2GB, which should be reasonable.
-// Keys must have non-zero length; values can have zero length.
-
-// K and V are some POD type
-// K : the key type
-// V : value array type
-template <typename K, typename V>
-class LinearDiskCache {
-public:
-    // return number of read entries
-    u32 OpenAndRead(const char* filename, LinearDiskCacheReader<K, V>& reader) {
-        using std::ios_base;
-
-        // close any currently opened file
-        Close();
-        m_num_entries = 0;
-
-        // try opening for reading/writing
-        OpenFStream(m_file, filename, ios_base::in | ios_base::out | ios_base::binary);
-
-        m_file.seekg(0, std::ios::end);
-        std::fstream::pos_type end_pos = m_file.tellg();
-        m_file.seekg(0, std::ios::beg);
-        std::fstream::pos_type start_pos = m_file.tellg();
-        std::streamoff file_size = end_pos - start_pos;
-
-        if (m_file.is_open() && ValidateHeader()) {
-            // good header, read some key/value pairs
-            K key;
-
-            V* value = nullptr;
-            u32 value_size;
-            u32 entry_number;
-
-            std::fstream::pos_type last_pos = m_file.tellg();
-
-            while (Read(&value_size)) {
-                std::streamoff next_extent =
-                    (last_pos - start_pos) + sizeof(value_size) + value_size;
-                if (next_extent > file_size)
-                    break;
-
-                delete[] value;
-                value = new V[value_size];
-
-                // read key/value and pass to reader
-                if (Read(&key) && Read(value, value_size) && Read(&entry_number) &&
-                    entry_number == m_num_entries + 1) {
-                    reader.Read(key, value, value_size);
-                } else {
-                    break;
-                }
-
-                m_num_entries++;
-                last_pos = m_file.tellg();
-            }
-            m_file.seekp(last_pos);
-            m_file.clear();
-
-            delete[] value;
-            return m_num_entries;
-        }
-
-        // failed to open file for reading or bad header
-        // close and recreate file
-        Close();
-        m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary);
-        WriteHeader();
-        return 0;
-    }
-
-    void Sync() {
-        m_file.flush();
-    }
-
-    void Close() {
-        if (m_file.is_open())
-            m_file.close();
-        // clear any error flags
-        m_file.clear();
-    }
-
-    // Appends a key-value pair to the store.
-    void Append(const K& key, const V* value, u32 value_size) {
-        // TODO: Should do a check that we don't already have "key"? (I think each caller does that
-        // already.)
-        Write(&value_size);
-        Write(&key);
-        Write(value, value_size);
-        m_num_entries++;
-        Write(&m_num_entries);
-    }
-
-private:
-    void WriteHeader() {
-        Write(&m_header);
-    }
-
-    bool ValidateHeader() {
-        char file_header[sizeof(Header)];
-
-        return (Read(file_header, sizeof(Header)) &&
-                !memcmp((const char*)&m_header, file_header, sizeof(Header)));
-    }
-
-    template <typename D>
-    bool Write(const D* data, u32 count = 1) {
-        return m_file.write((const char*)data, count * sizeof(D)).good();
-    }
-
-    template <typename D>
-    bool Read(const D* data, u32 count = 1) {
-        return m_file.read((char*)data, count * sizeof(D)).good();
-    }
-
-    struct Header {
-        Header() : id(*(u32*)"DCAC"), key_t_size(sizeof(K)), value_t_size(sizeof(V)) {
-            memcpy(ver, scm_rev_git_str, 40);
-        }
-
-        const u32 id;
-        const u16 key_t_size, value_t_size;
-        char ver[40];
-
-    } m_header;
-
-    std::fstream m_file;
-    u32 m_num_entries;
-};

src/common/logging/backend.cpp

@@ -4,17 +4,146 @@
 
 #include <algorithm>
 #include <array>
-#include <cstdio>
+#include <chrono>
+#include <climits>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#ifdef _WIN32
+#include <share.h> // For _SH_DENYWR
+#else
+#define _SH_DENYWR 0
+#endif
 #include "common/assert.h"
 #include "common/common_funcs.h" // snprintf compatibility define
 #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"
+#include "common/threadsafe_queue.h"
 
 namespace Log {
 
+/**
+ * Static state as a singleton.
+ */
+class Impl {
+public:
+    static Impl& Instance() {
+        static Impl backend;
+        return backend;
+    }
+
+    Impl(Impl const&) = delete;
+    const Impl& operator=(Impl const&) = delete;
+
+    void PushEntry(Entry e) {
+        std::lock_guard<std::mutex> lock(message_mutex);
+        message_queue.Push(std::move(e));
+        message_cv.notify_one();
+    }
+
+    void AddBackend(std::unique_ptr<Backend> backend) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        backends.push_back(std::move(backend));
+    }
+
+    void RemoveBackend(const std::string& backend_name) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        auto it = std::remove_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
+            return !strcmp(i->GetName(), backend_name.c_str());
+        });
+        backends.erase(it, backends.end());
+    }
+
+    const Filter& GetGlobalFilter() const {
+        return filter;
+    }
+
+    void SetGlobalFilter(const Filter& f) {
+        filter = f;
+    }
+
+    Backend* GetBackend(const std::string& backend_name) {
+        auto it = std::find_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
+            return !strcmp(i->GetName(), backend_name.c_str());
+        });
+        if (it == backends.end())
+            return nullptr;
+        return it->get();
+    }
+
+private:
+    Impl() {
+        backend_thread = std::thread([&] {
+            Entry entry;
+            auto write_logs = [&](Entry& e) {
+                std::lock_guard<std::mutex> lock(writing_mutex);
+                for (const auto& backend : backends) {
+                    backend->Write(e);
+                }
+            };
+            while (true) {
+                {
+                    std::unique_lock<std::mutex> lock(message_mutex);
+                    message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
+                }
+                if (!running) {
+                    break;
+                }
+                write_logs(entry);
+            }
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
+            // where a system is repeatedly spamming logs even on close.
+            const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
+            int logs_written = 0;
+            while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
+                write_logs(entry);
+            }
+        });
+    }
+
+    ~Impl() {
+        running = false;
+        message_cv.notify_one();
+        backend_thread.join();
+    }
+
+    std::atomic_bool running{true};
+    std::mutex message_mutex, writing_mutex;
+    std::condition_variable message_cv;
+    std::thread backend_thread;
+    std::vector<std::unique_ptr<Backend>> backends;
+    Common::MPSCQueue<Log::Entry> message_queue;
+    Filter filter;
+};
+
+void ConsoleBackend::Write(const Entry& entry) {
+    PrintMessage(entry);
+}
+
+void ColorConsoleBackend::Write(const Entry& entry) {
+    PrintColoredMessage(entry);
+}
+
+// _SH_DENYWR allows read only access to the file for other programs.
+// It is #defined to 0 on other platforms
+FileBackend::FileBackend(const std::string& filename)
+    : file(filename, "w", _SH_DENYWR), bytes_written(0) {}
+
+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 size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
+    if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
+        return;
+    }
+    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
+    if (entry.log_level >= Level::Error) {
+        file.Flush();
+    }
+}
+
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
     CLS(Log)                                                                                       \
@@ -38,16 +167,19 @@ namespace Log {
     SUB(Service, AM)                                                                               \
     SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
+    SUB(Service, BCAT)                                                                             \
     SUB(Service, Fatal)                                                                            \
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
     SUB(Service, LM)                                                                               \
+    SUB(Service, MM)                                                                               \
     SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
     SUB(Service, PCTL)                                                                             \
+    SUB(Service, PREPO)                                                                            \
     SUB(Service, SET)                                                                              \
     SUB(Service, SM)                                                                               \
     SUB(Service, SPL)                                                                              \
@@ -125,35 +257,32 @@ Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsign
     return entry;
 }
 
-static Filter* filter = nullptr;
-
-void SetFilter(Filter* new_filter) {
-    filter = new_filter;
+void SetGlobalFilter(const Filter& filter) {
+    Impl::Instance().SetGlobalFilter(filter);
 }
 
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                const char* function, const char* format, ...) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
-        return;
-    std::array<char, 4 * 1024> formatting_buffer;
-    va_list args;
-    va_start(args, format);
-    vsnprintf(formatting_buffer.data(), formatting_buffer.size(), format, args);
-    va_end(args);
-    Entry entry = CreateEntry(log_class, log_level, filename, line_num, function,
-                              std::string(formatting_buffer.data()));
+void AddBackend(std::unique_ptr<Backend> backend) {
+    Impl::Instance().AddBackend(std::move(backend));
+}
 
-    PrintColoredMessage(entry);
+void RemoveBackend(const std::string& backend_name) {
+    Impl::Instance().RemoveBackend(backend_name);
+}
+
+Backend* GetBackend(const std::string& backend_name) {
+    return Impl::Instance().GetBackend(backend_name);
 }
 
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
                        unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
+    auto filter = Impl::Instance().GetGlobalFilter();
+    if (!filter.CheckMessage(log_class, log_level))
         return;
+
     Entry entry =
         CreateEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
 
-    PrintColoredMessage(entry);
+    Impl::Instance().PushEntry(std::move(entry));
 }
 } // namespace Log

src/common/logging/backend.h

@@ -1,13 +1,15 @@
 // Copyright 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-
 #pragma once
 
 #include <chrono>
 #include <cstdarg>
+#include <memory>
 #include <string>
 #include <utility>
+#include "common/file_util.h"
+#include "common/logging/filter.h"
 #include "common/logging/log.h"
 
 namespace Log {
@@ -34,6 +36,80 @@ struct Entry {
     Entry& operator=(const Entry& o) = default;
 };
 
+/**
+ * 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
+ */
+class Backend {
+public:
+    virtual ~Backend() = default;
+    virtual void SetFilter(const Filter& new_filter) {
+        filter = new_filter;
+    }
+    virtual const char* GetName() const = 0;
+    virtual void Write(const Entry& entry) = 0;
+
+private:
+    Filter filter;
+};
+
+/**
+ * Backend that writes to stderr without any color commands
+ */
+class ConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "console";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to stderr and with color
+ */
+class ColorConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "color_console";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to a file passed into the constructor
+ */
+class FileBackend : public Backend {
+public:
+    explicit FileBackend(const std::string& filename);
+
+    static const char* Name() {
+        return "file";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+
+    void Write(const Entry& entry) override;
+
+private:
+    FileUtil::IOFile file;
+    size_t bytes_written;
+};
+
+void AddBackend(std::unique_ptr<Backend> backend);
+
+void RemoveBackend(const std::string& backend_name);
+
+Backend* GetBackend(const std::string& 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.
@@ -49,5 +125,10 @@ const char* GetLevelName(Level log_level);
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                   const char* function, std::string message);
 
-void SetFilter(Filter* filter);
-} // namespace Log
+/**
+ * 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
+ * never get the message
+ */
+void SetGlobalFilter(const Filter& filter);
+} // namespace Log

src/common/logging/filter.cpp

@@ -65,14 +65,14 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
                              const std::string::const_iterator end) {
     auto level_separator = std::find(begin, end, ':');
     if (level_separator == end) {
-        NGLOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
-                    std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}",
+                  std::string(begin, end));
         return false;
     }
 
     const Level level = GetLevelByName(level_separator + 1, end);
     if (level == Level::Count) {
-        NGLOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log level in filter: {}", std::string(begin, end));
         return false;
     }
 
@@ -83,7 +83,7 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
 
     const Class log_class = GetClassByName(begin, level_separator);
     if (log_class == Class::Count) {
-        NGLOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log class in filter: {}", std::string(begin, end));
         return false;
     }
 
@@ -94,4 +94,11 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
 bool Filter::CheckMessage(Class log_class, Level level) const {
     return static_cast<u8>(level) >= static_cast<u8>(class_levels[static_cast<size_t>(log_class)]);
 }
+
+bool Filter::IsDebug() const {
+    return std::any_of(class_levels.begin(), class_levels.end(), [](const Level& l) {
+        return static_cast<u8>(l) <= static_cast<u8>(Level::Debug);
+    });
+}
+
 } // namespace Log

src/common/logging/filter.h

@@ -47,6 +47,9 @@ public:
     /// Matches class/level combination against the filter, returning true if it passed.
     bool CheckMessage(Class log_class, Level level) const;
 
+    /// Returns true if any logging classes are set to debug
+    bool IsDebug() const;
+
 private:
     std::array<Level, (size_t)Class::Count> class_levels;
 };

src/common/logging/log.h

@@ -55,16 +55,19 @@ enum class Class : ClassType {
     Service_AOC,       ///< The AOC (AddOn Content) service
     Service_APM,       ///< The APM (Performance) service
     Service_Audio,     ///< The Audio (Audio control) service
+    Service_BCAT,      ///< The BCAT service
     Service_Fatal,     ///< The Fatal service
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
     Service_HID,       ///< The HID (Human interface device) service
     Service_LM,        ///< The LM (Logger) service
+    Service_MM,        ///< The MM (Multimedia) service
     Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCTL,      ///< The PCTL (Parental control) service
+    Service_PREPO,     ///< The PREPO (Play report) service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
     Service_SPL,       ///< The SPL service
@@ -91,19 +94,6 @@ enum class Class : ClassType {
     Count              ///< Total number of logging classes
 };
 
-/// Logs a message to the global logger.
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                const char* function,
-#ifdef _MSC_VER
-                _Printf_format_string_
-#endif
-                const char* format,
-                ...)
-#ifdef __GNUC__
-    __attribute__((format(printf, 6, 7)))
-#endif
-    ;
-
 /// 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,
@@ -118,48 +108,26 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig
 
 } // namespace Log
 
-#define LOG_GENERIC(log_class, log_level, ...)                                                     \
-    ::Log::LogMessage(log_class, log_level, __FILE__, __LINE__, __func__, __VA_ARGS__)
-
 #ifdef _DEBUG
 #define LOG_TRACE(log_class, ...)                                                                  \
-    LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Trace, __VA_ARGS__)
-#else
-#define LOG_TRACE(log_class, ...) (void(0))
-#endif
-
-#define LOG_DEBUG(log_class, ...)                                                                  \
-    LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Debug, __VA_ARGS__)
-#define LOG_INFO(log_class, ...)                                                                   \
-    LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Info, __VA_ARGS__)
-#define LOG_WARNING(log_class, ...)                                                                \
-    LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Warning, __VA_ARGS__)
-#define LOG_ERROR(log_class, ...)                                                                  \
-    LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Error, __VA_ARGS__)
-#define LOG_CRITICAL(log_class, ...)                                                               \
-    LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Critical, __VA_ARGS__)
-
-// Define the fmt lib macros
-#ifdef _DEBUG
-#define NGLOG_TRACE(log_class, ...)                                                                \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace, __FILE__, __LINE__,         \
                          __func__, __VA_ARGS__)
 #else
-#define NGLOG_TRACE(log_class, fmt, ...) (void(0))
+#define LOG_TRACE(log_class, fmt, ...) (void(0))
 #endif
 
-#define NGLOG_DEBUG(log_class, ...)                                                                \
+#define LOG_DEBUG(log_class, ...)                                                                  \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug, __FILE__, __LINE__,         \
                          __func__, __VA_ARGS__)
-#define NGLOG_INFO(log_class, ...)                                                                 \
+#define LOG_INFO(log_class, ...)                                                                   \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info, __FILE__, __LINE__,          \
                          __func__, __VA_ARGS__)
-#define NGLOG_WARNING(log_class, ...)                                                              \
+#define LOG_WARNING(log_class, ...)                                                                \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning, __FILE__, __LINE__,       \
                          __func__, __VA_ARGS__)
-#define NGLOG_ERROR(log_class, ...)                                                                \
+#define LOG_ERROR(log_class, ...)                                                                  \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error, __FILE__, __LINE__,         \
                          __func__, __VA_ARGS__)
-#define NGLOG_CRITICAL(log_class, ...)                                                             \
+#define LOG_CRITICAL(log_class, ...)                                                               \
     ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical, __FILE__, __LINE__,      \
                          __func__, __VA_ARGS__)

src/common/math_util.h

@@ -17,11 +17,6 @@ inline bool IntervalsIntersect(unsigned start0, unsigned length0, unsigned start
     return (std::max(start0, start1) < std::min(start0 + length0, start1 + length1));
 }
 
-template <typename T>
-inline T Clamp(const T val, const T& min, const T& max) {
-    return std::max(min, std::min(max, val));
-}
-
 template <class T>
 struct Rectangle {
     T left;

src/common/memory_util.cpp

@@ -16,7 +16,7 @@
 #include <sys/mman.h>
 #endif
 
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
 #include <unistd.h>
 #define PAGE_MASK (getpagesize() - 1)
 #define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
@@ -30,7 +30,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
     void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 #else
     static char* map_hint = nullptr;
-#if defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
     // This OS has no flag to enforce allocation below the 4 GB boundary,
     // but if we hint that we want a low address it is very likely we will
     // get one.
@@ -42,7 +42,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
     void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_ANON | MAP_PRIVATE
-#if defined(ARCHITECTURE_X64) && defined(MAP_32BIT)
+#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
                          | (low ? MAP_32BIT : 0)
 #endif
                          ,
@@ -57,7 +57,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
         LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
     }
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
     else {
         if (low) {
             map_hint += size;
@@ -113,7 +113,7 @@ void FreeMemoryPages(void* ptr, size_t size) {
     if (ptr) {
 #ifdef _WIN32
         if (!VirtualFree(ptr, 0, MEM_RELEASE))
-            LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n%s", GetLastErrorMsg());
+            LOG_ERROR(Common_Memory, "FreeMemoryPages failed!\n{}", GetLastErrorMsg());
 #else
         munmap(ptr, size);
 #endif
@@ -134,7 +134,7 @@ void WriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
 #ifdef _WIN32
     DWORD oldValue;
     if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
-        LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n%s", GetLastErrorMsg());
+        LOG_ERROR(Common_Memory, "WriteProtectMemory failed!\n{}", GetLastErrorMsg());
 #else
     mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ);
 #endif
@@ -145,7 +145,7 @@ void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
     DWORD oldValue;
     if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,
                         &oldValue))
-        LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n%s", GetLastErrorMsg());
+        LOG_ERROR(Common_Memory, "UnWriteProtectMemory failed!\n{}", GetLastErrorMsg());
 #else
     mprotect(ptr, size,
              allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ);
@@ -167,8 +167,7 @@ std::string MemUsage() {
         return "MemUsage Error";
 
     if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
-        Ret = Common::StringFromFormat(
-            "%s K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7).c_str());
+        Ret = fmt::format("{} K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7));
 
     CloseHandle(hProcess);
     return Ret;

src/common/param_package.cpp

@@ -25,7 +25,7 @@ ParamPackage::ParamPackage(const std::string& serialized) {
         std::vector<std::string> key_value;
         Common::SplitString(pair, KEY_VALUE_SEPARATOR, key_value);
         if (key_value.size() != 2) {
-            LOG_ERROR(Common, "invalid key pair %s", pair.c_str());
+            LOG_ERROR(Common, "invalid key pair {}", pair);
             continue;
         }
 
@@ -64,7 +64,7 @@ std::string ParamPackage::Serialize() const {
 std::string ParamPackage::Get(const std::string& key, const std::string& default_value) const {
     auto pair = data.find(key);
     if (pair == data.end()) {
-        LOG_DEBUG(Common, "key %s not found", key.c_str());
+        LOG_DEBUG(Common, "key '{}' not found", key);
         return default_value;
     }
 
@@ -74,14 +74,14 @@ std::string ParamPackage::Get(const std::string& key, const std::string& default
 int ParamPackage::Get(const std::string& key, int default_value) const {
     auto pair = data.find(key);
     if (pair == data.end()) {
-        LOG_DEBUG(Common, "key %s not found", key.c_str());
+        LOG_DEBUG(Common, "key '{}' not found", key);
         return default_value;
     }
 
     try {
         return std::stoi(pair->second);
     } catch (const std::logic_error&) {
-        LOG_ERROR(Common, "failed to convert %s to int", pair->second.c_str());
+        LOG_ERROR(Common, "failed to convert {} to int", pair->second);
         return default_value;
     }
 }
@@ -89,14 +89,14 @@ int ParamPackage::Get(const std::string& key, int default_value) const {
 float ParamPackage::Get(const std::string& key, float default_value) const {
     auto pair = data.find(key);
     if (pair == data.end()) {
-        LOG_DEBUG(Common, "key %s not found", key.c_str());
+        LOG_DEBUG(Common, "key {} not found", key);
         return default_value;
     }
 
     try {
         return std::stof(pair->second);
     } catch (const std::logic_error&) {
-        LOG_ERROR(Common, "failed to convert %s to float", pair->second.c_str());
+        LOG_ERROR(Common, "failed to convert {} to float", pair->second);
         return default_value;
     }
 }

src/common/string_util.cpp

@@ -46,76 +46,6 @@ bool AsciiToHex(const char* _szValue, u32& result) {
     return true;
 }
 
-bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args) {
-    int writtenCount;
-
-#ifdef _MSC_VER
-    // You would think *printf are simple, right? Iterate on each character,
-    // if it's a format specifier handle it properly, etc.
-    //
-    // Nooooo. Not according to the C standard.
-    //
-    // According to the C99 standard (7.19.6.1 "The fprintf function")
-    //     The format shall be a multibyte character sequence
-    //
-    // Because some character encodings might have '%' signs in the middle of
-    // a multibyte sequence (SJIS for example only specifies that the first
-    // byte of a 2 byte sequence is "high", the second byte can be anything),
-    // printf functions have to decode the multibyte sequences and try their
-    // best to not screw up.
-    //
-    // Unfortunately, on Windows, the locale for most languages is not UTF-8
-    // as we would need. Notably, for zh_TW, Windows chooses EUC-CN as the
-    // locale, and completely fails when trying to decode UTF-8 as EUC-CN.
-    //
-    // On the other hand, the fix is simple: because we use UTF-8, no such
-    // multibyte handling is required as we can simply assume that no '%' char
-    // will be present in the middle of a multibyte sequence.
-    //
-    // This is why we lookup an ANSI (cp1252) locale here and use _vsnprintf_l.
-    static locale_t c_locale = nullptr;
-    if (!c_locale)
-        c_locale = _create_locale(LC_ALL, ".1252");
-    writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args);
-#else
-    writtenCount = vsnprintf(out, outsize, format, args);
-#endif
-
-    if (writtenCount > 0 && writtenCount < outsize) {
-        out[writtenCount] = '\0';
-        return true;
-    } else {
-        out[outsize - 1] = '\0';
-        return false;
-    }
-}
-
-std::string StringFromFormat(const char* format, ...) {
-    va_list args;
-    char* buf = nullptr;
-#ifdef _WIN32
-    int required = 0;
-
-    va_start(args, format);
-    required = _vscprintf(format, args);
-    buf = new char[required + 1];
-    CharArrayFromFormatV(buf, required + 1, format, args);
-    va_end(args);
-
-    std::string temp = buf;
-    delete[] buf;
-#else
-    va_start(args, format);
-    if (vasprintf(&buf, format, args) < 0)
-        LOG_ERROR(Common, "Unable to allocate memory for string");
-    va_end(args);
-
-    std::string temp = buf;
-    free(buf);
-#endif
-    return temp;
-}
-
 // For Debugging. Read out an u8 array.
 std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces) {
     std::ostringstream oss;
@@ -134,6 +64,10 @@ std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces
     return oss.str();
 }
 
+std::string StringFromBuffer(const std::vector<u8>& data) {
+    return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
+}
+
 // Turns "  hej " into "hej". Also handles tabs.
 std::string StripSpaces(const std::string& str) {
     const size_t s = str.find_first_not_of(" \t\r\n");
@@ -200,7 +134,7 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     size_t dir_end = full_path.find_last_of("/"
 // windows needs the : included for something like just "C:" to be considered a directory
 #ifdef _WIN32
-                                            ":"
+                                            "\\:"
 #endif
     );
     if (std::string::npos == dir_end)
@@ -347,7 +281,7 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
 
     iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
     if ((iconv_t)(-1) == conv_desc) {
-        LOG_ERROR(Common, "Iconv initialization failure [%s]: %s", fromcode, strerror(errno));
+        LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
         iconv_close(conv_desc);
         return {};
     }
@@ -376,7 +310,7 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
                     ++src_buffer;
                 }
             } else {
-                LOG_ERROR(Common, "iconv failure [%s]: %s", fromcode, strerror(errno));
+                LOG_ERROR(Common, "iconv failure [{}]: {}", fromcode, strerror(errno));
                 break;
             }
         }
@@ -395,7 +329,7 @@ std::u16string UTF8ToUTF16(const std::string& input) {
 
     iconv_t const conv_desc = iconv_open("UTF-16LE", "UTF-8");
     if ((iconv_t)(-1) == conv_desc) {
-        LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: %s", strerror(errno));
+        LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
         iconv_close(conv_desc);
         return {};
     }
@@ -424,7 +358,7 @@ std::u16string UTF8ToUTF16(const std::string& input) {
                     ++src_buffer;
                 }
             } else {
-                LOG_ERROR(Common, "iconv failure [UTF-8]: %s", strerror(errno));
+                LOG_ERROR(Common, "iconv failure [UTF-8]: {}", strerror(errno));
                 break;
             }
         }

src/common/string_util.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <cstdarg>
 #include <cstddef>
 #include <iomanip>
 #include <sstream>
@@ -20,21 +19,10 @@ std::string ToLower(std::string str);
 /// Make a string uppercase
 std::string ToUpper(std::string str);
 
-std::string StringFromFormat(const char* format, ...);
-// Cheap!
-bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args);
-
-template <size_t Count>
-inline void CharArrayFromFormat(char (&out)[Count], const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    CharArrayFromFormatV(out, Count, format, args);
-    va_end(args);
-}
-
-// Good
 std::string ArrayToString(const u8* data, size_t size, int line_len = 20, bool spaces = true);
 
+std::string StringFromBuffer(const std::vector<u8>& data);
+
 std::string StripSpaces(const std::string& s);
 std::string StripQuotes(const std::string& s);
 

src/common/swap.h

@@ -69,7 +69,7 @@ inline u32 swap32(u32 _data) {
 inline u64 swap64(u64 _data) {
     return _byteswap_uint64(_data);
 }
-#elif _M_ARM
+#elif ARCHITECTURE_ARM
 inline u16 swap16(u16 _data) {
     u32 data = _data;
     __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));

src/common/telemetry.h

@@ -52,27 +52,14 @@ public:
 template <typename T>
 class Field : public FieldInterface {
 public:
-    Field(FieldType type, std::string name, const T& value)
-        : name(std::move(name)), type(type), value(value) {}
-
-    Field(FieldType type, std::string name, T&& value)
+    Field(FieldType type, std::string name, T value)
         : name(std::move(name)), type(type), value(std::move(value)) {}
 
-    Field(const Field& other) : Field(other.type, other.name, other.value) {}
+    Field(const Field&) = default;
+    Field& operator=(const Field&) = default;
 
-    Field& operator=(const Field& other) {
-        type = other.type;
-        name = other.name;
-        value = other.value;
-        return *this;
-    }
-
-    Field& operator=(Field&& other) {
-        type = other.type;
-        name = std::move(other.name);
-        value = std::move(other.value);
-        return *this;
-    }
+    Field(Field&&) = default;
+    Field& operator=(Field&& other) = default;
 
     void Accept(VisitorInterface& visitor) const override;
 
@@ -94,11 +81,11 @@ public:
         return value;
     }
 
-    inline bool operator==(const Field<T>& other) {
+    bool operator==(const Field& other) const {
         return (type == other.type) && (name == other.name) && (value == other.value);
     }
 
-    inline bool operator!=(const Field<T>& other) {
+    bool operator!=(const Field& other) const {
         return !(*this == other);
     }
 

src/common/thread.h

@@ -11,25 +11,6 @@
 #include <thread>
 #include "common/common_types.h"
 
-// Support for C++11's thread_local keyword was surprisingly spotty in compilers until very
-// recently. Fortunately, thread local variables have been well supported for compilers for a while,
-// but with semantics supporting only POD types, so we can use a few defines to get some amount of
-// backwards compat support.
-// WARNING: This only works correctly with POD types.
-#if defined(__clang__)
-#if !__has_feature(cxx_thread_local)
-#define thread_local __thread
-#endif
-#elif defined(__GNUC__)
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
-#define thread_local __thread
-#endif
-#elif defined(_MSC_VER)
-#if _MSC_VER < 1900
-#define thread_local __declspec(thread)
-#endif
-#endif
-
 namespace Common {
 
 int CurrentThreadId();

src/common/timer.cpp

@@ -2,7 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <time.h>
+#include <ctime>
+
+#include <fmt/format.h>
+
 #ifdef _WIN32
 #include <windows.h>
 // windows.h needs to be included before other windows headers
@@ -104,8 +107,8 @@ std::string Timer::GetTimeElapsedFormatted() const {
     // Hours
     u32 Hours = Minutes / 60;
 
-    std::string TmpStr = StringFromFormat("%02i:%02i:%02i:%03i", Hours, Minutes % 60, Seconds % 60,
-                                          Milliseconds % 1000);
+    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours, Minutes % 60, Seconds % 60,
+                                     Milliseconds % 1000);
     return TmpStr;
 }
 
@@ -165,11 +168,11 @@ std::string Timer::GetTimeFormatted() {
 #ifdef _WIN32
     struct timeb tp;
     (void)::ftime(&tp);
-    return StringFromFormat("%s:%03i", tmp, tp.millitm);
+    return fmt::format("{}:{:03}", tmp, tp.millitm);
 #else
     struct timeval t;
     (void)gettimeofday(&t, nullptr);
-    return StringFromFormat("%s:%03d", tmp, (int)(t.tv_usec / 1000));
+    return fmt::format("{}:{:03}", tmp, static_cast<int>(t.tv_usec / 1000));
 #endif
 }
 

src/common/vector_math.h

@@ -52,12 +52,8 @@ static inline Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w);
 template <typename T>
 class Vec2 {
 public:
-    T x;
-    T y;
-
-    T* AsArray() {
-        return &x;
-    }
+    T x{};
+    T y{};
 
     Vec2() = default;
     Vec2(const T& _x, const T& _y) : x(_x), y(_y) {}
@@ -71,11 +67,6 @@ public:
         return Vec2<T>(f, f);
     }
 
-    void Write(T a[2]) {
-        a[0] = x;
-        a[1] = y;
-    }
-
     Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
         return MakeVec(x + other.x, y + other.y);
     }
@@ -201,13 +192,9 @@ inline float Vec2<float>::Normalize() {
 template <typename T>
 class Vec3 {
 public:
-    T x;
-    T y;
-    T z;
-
-    T* AsArray() {
-        return &x;
-    }
+    T x{};
+    T y{};
+    T z{};
 
     Vec3() = default;
     Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) {}
@@ -225,12 +212,6 @@ public:
         return MakeVec(f, f, f);
     }
 
-    void Write(T a[3]) {
-        a[0] = x;
-        a[1] = y;
-        a[2] = z;
-    }
-
     Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
         return MakeVec(x + other.x, y + other.y, z + other.z);
     }
@@ -411,14 +392,10 @@ typedef Vec3<float> Vec3f;
 template <typename T>
 class Vec4 {
 public:
-    T x;
-    T y;
-    T z;
-    T w;
-
-    T* AsArray() {
-        return &x;
-    }
+    T x{};
+    T y{};
+    T z{};
+    T w{};
 
     Vec4() = default;
     Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) {}
@@ -436,13 +413,6 @@ public:
         return Vec4<T>(f, f, f, f);
     }
 
-    void Write(T a[4]) {
-        a[0] = x;
-        a[1] = y;
-        a[2] = z;
-        a[3] = w;
-    }
-
     Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
         return MakeVec(x + other.x, y + other.y, z + other.z, w + other.w);
     }

src/core/CMakeLists.txt

@@ -4,29 +4,31 @@ add_library(core STATIC
     arm/unicorn/arm_unicorn.h
     core.cpp
     core.h
+    core_cpu.cpp
+    core_cpu.h
     core_timing.cpp
     core_timing.h
+    file_sys/content_archive.cpp
+    file_sys/content_archive.h
     file_sys/directory.h
-    file_sys/disk_filesystem.cpp
-    file_sys/disk_filesystem.h
     file_sys/errors.h
-    file_sys/filesystem.cpp
-    file_sys/filesystem.h
+    file_sys/mode.h
     file_sys/partition_filesystem.cpp
     file_sys/partition_filesystem.h
-    file_sys/path_parser.cpp
-    file_sys/path_parser.h
     file_sys/program_metadata.cpp
     file_sys/program_metadata.h
     file_sys/romfs_factory.cpp
     file_sys/romfs_factory.h
-    file_sys/romfs_filesystem.cpp
-    file_sys/romfs_filesystem.h
     file_sys/savedata_factory.cpp
     file_sys/savedata_factory.h
     file_sys/sdmc_factory.cpp
     file_sys/sdmc_factory.h
-    file_sys/storage.h
+    file_sys/vfs.cpp
+    file_sys/vfs.h
+    file_sys/vfs_offset.cpp
+    file_sys/vfs_offset.h
+    file_sys/vfs_real.cpp
+    file_sys/vfs_real.h
     frontend/emu_window.cpp
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
@@ -38,12 +40,12 @@ add_library(core STATIC
     hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
+    hle/kernel/address_arbiter.cpp
+    hle/kernel/address_arbiter.h
     hle/kernel/client_port.cpp
     hle/kernel/client_port.h
     hle/kernel/client_session.cpp
     hle/kernel/client_session.h
-    hle/kernel/condition_variable.cpp
-    hle/kernel/condition_variable.h
     hle/kernel/errors.h
     hle/kernel/event.cpp
     hle/kernel/event.h
@@ -124,6 +126,12 @@ add_library(core STATIC
     hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
+    hle/service/audio/hwopus.cpp
+    hle/service/audio/hwopus.h
+    hle/service/bcat/module.cpp
+    hle/service/bcat/module.h
+    hle/service/bcat/bcat.cpp
+    hle/service/bcat/bcat.h
     hle/service/fatal/fatal.cpp
     hle/service/fatal/fatal.h
     hle/service/fatal/fatal_p.cpp
@@ -144,6 +152,8 @@ add_library(core STATIC
     hle/service/hid/hid.h
     hle/service/lm/lm.cpp
     hle/service/lm/lm.h
+    hle/service/mm/mm_u.cpp
+    hle/service/mm/mm_u.h
     hle/service/nifm/nifm.cpp
     hle/service/nifm/nifm.h
     hle/service/nifm/nifm_a.cpp
@@ -171,6 +181,8 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
     hle/service/nvdrv/devices/nvhost_gpu.cpp
     hle/service/nvdrv/devices/nvhost_gpu.h
+    hle/service/nvdrv/devices/nvhost_nvdec.cpp
+    hle/service/nvdrv/devices/nvhost_nvdec.h
     hle/service/nvdrv/devices/nvmap.cpp
     hle/service/nvdrv/devices/nvmap.h
     hle/service/nvdrv/interface.cpp
@@ -183,10 +195,12 @@ add_library(core STATIC
     hle/service/nvflinger/buffer_queue.h
     hle/service/nvflinger/nvflinger.cpp
     hle/service/nvflinger/nvflinger.h
+    hle/service/pctl/module.cpp
+    hle/service/pctl/module.h
     hle/service/pctl/pctl.cpp
     hle/service/pctl/pctl.h
-    hle/service/pctl/pctl_a.cpp
-    hle/service/pctl/pctl_a.h
+    hle/service/prepo/prepo.cpp
+    hle/service/prepo/prepo.h
     hle/service/service.cpp
     hle/service/service.h
     hle/service/set/set.cpp
@@ -247,12 +261,15 @@ add_library(core STATIC
     loader/linker.h
     loader/loader.cpp
     loader/loader.h
+    loader/nca.cpp
+    loader/nca.h
     loader/nro.cpp
     loader/nro.h
     loader/nso.cpp
     loader/nso.h
     memory.cpp
     memory.h
+    memory_hook.cpp
     memory_hook.h
     memory_setup.h
     perf_stats.cpp

src/core/arm/arm_interface.h

@@ -116,6 +116,8 @@ public:
      */
     virtual void LoadContext(const ThreadContext& ctx) = 0;
 
+    virtual void ClearExclusiveState() = 0;
+
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
 };

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -55,8 +55,8 @@ public:
     }
 
     void InterpreterFallback(u64 pc, size_t num_instructions) override {
-        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x%" PRIx64 " for %zu instructions (instr = %08x)",
-                 pc, num_instructions, MemoryReadCode(pc));
+        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+                 num_instructions, MemoryReadCode(pc));
 
         ARM_Interface::ThreadContext ctx;
         parent.SaveContext(ctx);
@@ -76,7 +76,7 @@ public:
         case Dynarmic::A64::Exception::Yield:
             return;
         default:
-            ASSERT_MSG(false, "ExceptionRaised(exception = %zu, pc = %" PRIx64 ")",
+            ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:X})",
                        static_cast<size_t>(exception), pc);
         }
     }
@@ -226,6 +226,10 @@ void ARM_Dynarmic::ClearInstructionCache() {
     jit->ClearCache();
 }
 
+void ARM_Dynarmic::ClearExclusiveState() {
+    jit->ClearExclusiveState();
+}
+
 void ARM_Dynarmic::PageTableChanged() {
     jit = MakeJit(cb);
     current_page_table = Memory::GetCurrentPageTable();

src/core/arm/dynarmic/arm_dynarmic.h

@@ -39,6 +39,7 @@ public:
     void LoadContext(const ThreadContext& ctx) override;
 
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
     void PageTableChanged() override;

src/core/arm/unicorn/arm_unicorn.cpp

@@ -30,11 +30,22 @@ LoadDll LoadDll::g_load_dll;
 #define CHECKED(expr)                                                                              \
     do {                                                                                           \
         if (auto _cerr = (expr)) {                                                                 \
-            ASSERT_MSG(false, "Call " #expr " failed with error: %u (%s)\n", _cerr,                \
+            ASSERT_MSG(false, "Call " #expr " failed with error: {} ({})\n", _cerr,                \
                        uc_strerror(_cerr));                                                        \
         }                                                                                          \
     } while (0)
 
+static void CodeHook(uc_engine* uc, uint64_t address, uint32_t size, void* user_data) {
+    GDBStub::BreakpointAddress bkpt =
+        GDBStub::GetNextBreakpointFromAddress(address, GDBStub::BreakpointType::Execute);
+    if (GDBStub::IsMemoryBreak() ||
+        (bkpt.type != GDBStub::BreakpointType::None && address == bkpt.address)) {
+        auto core = static_cast<ARM_Unicorn*>(user_data);
+        core->RecordBreak(bkpt);
+        uc_emu_stop(uc);
+    }
+}
+
 static void InterruptHook(uc_engine* uc, u32 intNo, void* user_data) {
     u32 esr{};
     CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr));
@@ -52,8 +63,8 @@ static void InterruptHook(uc_engine* uc, u32 intNo, void* user_data) {
 static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value,
                                void* user_data) {
     ARM_Interface::ThreadContext ctx{};
-    Core::CPU().SaveContext(ctx);
-    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%lx, pc=0x%lx, lr=0x%lx", addr,
+    Core::CurrentArmInterface().SaveContext(ctx);
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x{:X}, pc=0x{:X}, lr=0x{:X}", addr,
                ctx.pc, ctx.cpu_registers[30]);
     return {};
 }
@@ -67,6 +78,10 @@ ARM_Unicorn::ARM_Unicorn() {
     uc_hook hook{};
     CHECKED(uc_hook_add(uc, &hook, UC_HOOK_INTR, (void*)InterruptHook, this, 0, -1));
     CHECKED(uc_hook_add(uc, &hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, this, 0, -1));
+    if (GDBStub::IsServerEnabled()) {
+        CHECKED(uc_hook_add(uc, &hook, UC_HOOK_CODE, (void*)CodeHook, this, 0, -1));
+        last_bkpt_hit = false;
+    }
 }
 
 ARM_Unicorn::~ARM_Unicorn() {
@@ -155,7 +170,11 @@ void ARM_Unicorn::SetTlsAddress(VAddr base) {
 }
 
 void ARM_Unicorn::Run() {
-    ExecuteInstructions(std::max(CoreTiming::GetDowncount(), 0));
+    if (GDBStub::IsServerEnabled()) {
+        ExecuteInstructions(std::max(4000000, 0));
+    } else {
+        ExecuteInstructions(std::max(CoreTiming::GetDowncount(), 0));
+    }
 }
 
 void ARM_Unicorn::Step() {
@@ -168,6 +187,18 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
     MICROPROFILE_SCOPE(ARM_Jit);
     CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
     CoreTiming::AddTicks(num_instructions);
+    if (GDBStub::IsServerEnabled()) {
+        if (last_bkpt_hit) {
+            uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);
+        }
+        Kernel::Thread* thread = Kernel::GetCurrentThread();
+        SaveContext(thread->context);
+        if (last_bkpt_hit || (num_instructions == 1)) {
+            last_bkpt_hit = false;
+            GDBStub::Break();
+            GDBStub::SendTrap(thread, 5);
+        }
+    }
 }
 
 void ARM_Unicorn::SaveContext(ARM_Interface::ThreadContext& ctx) {
@@ -232,4 +263,11 @@ void ARM_Unicorn::PrepareReschedule() {
     CHECKED(uc_emu_stop(uc));
 }
 
+void ARM_Unicorn::ClearExclusiveState() {}
+
 void ARM_Unicorn::ClearInstructionCache() {}
+
+void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
+    last_bkpt = bkpt;
+    last_bkpt_hit = true;
+}

src/core/arm/unicorn/arm_unicorn.h

@@ -7,6 +7,7 @@
 #include <unicorn/unicorn.h>
 #include "common/common_types.h"
 #include "core/arm/arm_interface.h"
+#include "core/gdbstub/gdbstub.h"
 
 class ARM_Unicorn final : public ARM_Interface {
 public:
@@ -30,12 +31,16 @@ public:
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
     void ExecuteInstructions(int num_instructions);
     void Run() override;
     void Step() override;
     void ClearInstructionCache() override;
     void PageTableChanged() override{};
+    void RecordBreak(GDBStub::BreakpointAddress bkpt);
 
 private:
     uc_engine* uc{};
+    GDBStub::BreakpointAddress last_bkpt{};
+    bool last_bkpt_hit;
 };

src/core/core.cpp

@@ -5,32 +5,56 @@
 #include <memory>
 #include <utility>
 #include "common/logging/log.h"
-#ifdef ARCHITECTURE_x86_64
-#include "core/arm/dynarmic/arm_dynarmic.h"
-#endif
-#include "core/arm/unicorn/arm_unicorn.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/service.h"
+#include "core/hle/service/sm/controller.h"
+#include "core/hle/service/sm/sm.h"
 #include "core/hw/hw.h"
 #include "core/loader/loader.h"
 #include "core/memory_setup.h"
 #include "core/settings.h"
+#include "file_sys/vfs_real.h"
 #include "video_core/video_core.h"
 
 namespace Core {
 
 /*static*/ System System::s_instance;
 
+System::System() = default;
+
+System::~System() = default;
+
+/// Runs a CPU core while the system is powered on
+static void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
+    while (Core::System::GetInstance().IsPoweredOn()) {
+        cpu_state->RunLoop(true);
+    }
+}
+
+Cpu& System::CurrentCpuCore() {
+    // If multicore is enabled, use host thread to figure out the current CPU core
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+
+    // Otherwise, use single-threaded mode active_core variable
+    return *cpu_cores[active_core];
+}
+
 System::ResultStatus System::RunLoop(bool tight_loop) {
     status = ResultStatus::Success;
-    if (!cpu_core) {
-        return ResultStatus::ErrorNotInitialized;
-    }
+
+    // Update thread_to_cpu in case Core 0 is run from a different host thread
+    thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
 
     if (GDBStub::IsServerEnabled()) {
         GDBStub::HandlePacket();
@@ -47,25 +71,14 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
         }
     }
 
-    // If we don't have a currently active thread then don't execute instructions,
-    // instead advance to the next event and try to yield to the next thread
-    if (Kernel::GetCurrentThread() == nullptr) {
-        LOG_TRACE(Core_ARM, "Idling");
-        CoreTiming::Idle();
-        CoreTiming::Advance();
-        PrepareReschedule();
-    } else {
-        CoreTiming::Advance();
-        if (tight_loop) {
-            cpu_core->Run();
-        } else {
-            cpu_core->Step();
+    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+        cpu_cores[active_core]->RunLoop(tight_loop);
+        if (Settings::values.use_multi_core) {
+            // Cores 1-3 are run on other threads in this mode
+            break;
         }
     }
 
-    HW::Update();
-    Reschedule();
-
     return status;
 }
 
@@ -74,17 +87,17 @@ System::ResultStatus System::SingleStep() {
 }
 
 System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& filepath) {
-    app_loader = Loader::GetLoader(filepath);
+    app_loader = Loader::GetLoader(std::make_shared<FileSys::RealVfsFile>(filepath));
 
     if (!app_loader) {
-        LOG_CRITICAL(Core, "Failed to obtain loader for %s!", filepath.c_str());
+        LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
         return ResultStatus::ErrorGetLoader;
     }
     std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
         app_loader->LoadKernelSystemMode();
 
     if (system_mode.second != Loader::ResultStatus::Success) {
-        LOG_CRITICAL(Core, "Failed to determine system mode (Error %i)!",
+        LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
                      static_cast<int>(system_mode.second));
 
         switch (system_mode.second) {
@@ -101,7 +114,7 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
 
     ResultStatus init_result{Init(emu_window, system_mode.first.get())};
     if (init_result != ResultStatus::Success) {
-        LOG_CRITICAL(Core, "Failed to initialize system (Error %i)!",
+        LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                      static_cast<int>(init_result));
         System::Shutdown();
         return init_result;
@@ -109,7 +122,7 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
 
     const Loader::ResultStatus load_result{app_loader->Load(current_process)};
     if (Loader::ResultStatus::Success != load_result) {
-        LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", static_cast<int>(load_result));
+        LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
         System::Shutdown();
 
         switch (load_result) {
@@ -128,21 +141,26 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
 }
 
 void System::PrepareReschedule() {
-    cpu_core->PrepareReschedule();
-    reschedule_pending = true;
+    CurrentCpuCore().PrepareReschedule();
 }
 
 PerfStats::Results System::GetAndResetPerfStats() {
     return perf_stats.GetAndResetStats(CoreTiming::GetGlobalTimeUs());
 }
 
-void System::Reschedule() {
-    if (!reschedule_pending) {
-        return;
-    }
+const std::shared_ptr<Kernel::Scheduler>& System::Scheduler(size_t core_index) {
+    ASSERT(core_index < NUM_CPU_CORES);
+    return cpu_cores[core_index]->Scheduler();
+}
 
-    reschedule_pending = false;
-    Core::System::GetInstance().Scheduler().Reschedule();
+ARM_Interface& System::ArmInterface(size_t core_index) {
+    ASSERT(core_index < NUM_CPU_CORES);
+    return cpu_cores[core_index]->ArmInterface();
+}
+
+Cpu& System::CpuCore(size_t core_index) {
+    ASSERT(core_index < NUM_CPU_CORES);
+    return *cpu_cores[core_index];
 }
 
 System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
@@ -152,31 +170,35 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
 
     current_process = Kernel::Process::Create("main");
 
-    if (Settings::values.use_cpu_jit) {
-#ifdef ARCHITECTURE_x86_64
-        cpu_core = std::make_shared<ARM_Dynarmic>();
-#else
-        cpu_core = std::make_shared<ARM_Unicorn>();
-        LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
-#endif
-    } else {
-        cpu_core = std::make_shared<ARM_Unicorn>();
+    cpu_barrier = std::make_shared<CpuBarrier>();
+    for (size_t index = 0; index < cpu_cores.size(); ++index) {
+        cpu_cores[index] = std::make_shared<Cpu>(cpu_barrier, index);
     }
 
     gpu_core = std::make_unique<Tegra::GPU>();
-
     telemetry_session = std::make_unique<Core::TelemetrySession>();
+    service_manager = std::make_shared<Service::SM::ServiceManager>();
 
     HW::Init();
     Kernel::Init(system_mode);
-    scheduler = std::make_unique<Kernel::Scheduler>(cpu_core.get());
-    Service::Init();
+    Service::Init(service_manager);
     GDBStub::Init();
 
     if (!VideoCore::Init(emu_window)) {
         return ResultStatus::ErrorVideoCore;
     }
 
+    // Create threads for CPU cores 1-3, and build thread_to_cpu map
+    // CPU core 0 is run on the main thread
+    thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
+    if (Settings::values.use_multi_core) {
+        for (size_t index = 0; index < cpu_core_threads.size(); ++index) {
+            cpu_core_threads[index] =
+                std::make_unique<std::thread>(RunCpuCore, cpu_cores[index + 1]);
+            thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1];
+        }
+    }
+
     LOG_DEBUG(Core, "Initialized OK");
 
     // Reset counters and set time origin to current frame
@@ -200,17 +222,41 @@ void System::Shutdown() {
     VideoCore::Shutdown();
     GDBStub::Shutdown();
     Service::Shutdown();
-    scheduler = nullptr;
     Kernel::Shutdown();
     HW::Shutdown();
-    telemetry_session = nullptr;
-    gpu_core = nullptr;
-    cpu_core = nullptr;
+    service_manager.reset();
+    telemetry_session.reset();
+    gpu_core.reset();
+
+    // Close all CPU/threading state
+    cpu_barrier->NotifyEnd();
+    if (Settings::values.use_multi_core) {
+        for (auto& thread : cpu_core_threads) {
+            thread->join();
+            thread.reset();
+        }
+    }
+    thread_to_cpu.clear();
+    for (auto& cpu_core : cpu_cores) {
+        cpu_core.reset();
+    }
+    cpu_barrier.reset();
+
+    // Close core timing
     CoreTiming::Shutdown();
 
-    app_loader = nullptr;
+    // Close app loader
+    app_loader.reset();
 
     LOG_DEBUG(Core, "Shutdown OK");
 }
 
+Service::SM::ServiceManager& System::ServiceManager() {
+    return *service_manager;
+}
+
+const Service::SM::ServiceManager& System::ServiceManager() const {
+    return *service_manager;
+}
+
 } // namespace Core

src/core/core.h

@@ -4,9 +4,12 @@
 
 #pragma once
 
+#include <array>
 #include <memory>
 #include <string>
+#include <thread>
 #include "common/common_types.h"
+#include "core/core_cpu.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
@@ -19,10 +22,16 @@
 class EmuWindow;
 class ARM_Interface;
 
+namespace Service::SM {
+class ServiceManager;
+}
+
 namespace Core {
 
 class System {
 public:
+    ~System();
+
     /**
      * Gets the instance of the System singleton class.
      * @returns Reference to the instance of the System singleton class.
@@ -83,7 +92,7 @@ public:
      * @returns True if the emulated system is powered on, otherwise false.
      */
     bool IsPoweredOn() const {
-        return cpu_core != nullptr;
+        return cpu_barrier && cpu_barrier->IsAlive();
     }
 
     /**
@@ -97,24 +106,34 @@ public:
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
 
+    /// Gets and resets core performance statistics
     PerfStats::Results GetAndResetPerfStats();
 
-    /**
-     * Gets a reference to the emulated CPU.
-     * @returns A reference to the emulated CPU.
-     */
-    ARM_Interface& CPU() {
-        return *cpu_core;
+    /// Gets an ARM interface to the CPU core that is currently running
+    ARM_Interface& CurrentArmInterface() {
+        return CurrentCpuCore().ArmInterface();
     }
 
+    /// Gets an ARM interface to the CPU core with the specified index
+    ARM_Interface& ArmInterface(size_t core_index);
+
+    /// Gets a CPU interface to the CPU core with the specified index
+    Cpu& CpuCore(size_t core_index);
+
+    /// Gets the GPU interface
     Tegra::GPU& GPU() {
         return *gpu_core;
     }
 
-    Kernel::Scheduler& Scheduler() {
-        return *scheduler;
+    /// Gets the scheduler for the CPU core that is currently running
+    Kernel::Scheduler& CurrentScheduler() {
+        return *CurrentCpuCore().Scheduler();
     }
 
+    /// Gets the scheduler for the CPU core with the specified index
+    const std::shared_ptr<Kernel::Scheduler>& Scheduler(size_t core_index);
+
+    /// Gets the current process
     Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
         return current_process;
     }
@@ -137,6 +156,9 @@ public:
         return *app_loader;
     }
 
+    Service::SM::ServiceManager& ServiceManager();
+    const Service::SM::ServiceManager& ServiceManager() const;
+
     void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context) {
         debug_context = std::move(context);
     }
@@ -146,6 +168,11 @@ public:
     }
 
 private:
+    System();
+
+    /// Returns the currently running CPU core
+    Cpu& CurrentCpuCore();
+
     /**
      * Initialize the emulated system.
      * @param emu_window Pointer to the host-system window used for video output and keyboard input.
@@ -154,22 +181,18 @@ private:
      */
     ResultStatus Init(EmuWindow* emu_window, u32 system_mode);
 
-    /// Reschedule the core emulation
-    void Reschedule();
-
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
-
-    std::shared_ptr<ARM_Interface> cpu_core;
-    std::unique_ptr<Kernel::Scheduler> scheduler;
     std::unique_ptr<Tegra::GPU> gpu_core;
-
     std::shared_ptr<Tegra::DebugContext> debug_context;
-
     Kernel::SharedPtr<Kernel::Process> current_process;
+    std::shared_ptr<CpuBarrier> cpu_barrier;
+    std::array<std::shared_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
+    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
+    size_t active_core{}; ///< Active core, only used in single thread mode
 
-    /// When true, signals that a reschedule should happen
-    bool reschedule_pending{};
+    /// Service manager
+    std::shared_ptr<Service::SM::ServiceManager> service_manager;
 
     /// Telemetry session for this emulation session
     std::unique_ptr<Core::TelemetrySession> telemetry_session;
@@ -178,10 +201,13 @@ private:
 
     ResultStatus status = ResultStatus::Success;
     std::string status_details = "";
+
+    /// Map of guest threads to CPU cores
+    std::map<std::thread::id, std::shared_ptr<Cpu>> thread_to_cpu;
 };
 
-inline ARM_Interface& CPU() {
-    return System::GetInstance().CPU();
+inline ARM_Interface& CurrentArmInterface() {
+    return System::GetInstance().CurrentArmInterface();
 }
 
 inline TelemetrySession& Telemetry() {

src/core/core_cpu.cpp

@@ -0,0 +1,119 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <condition_variable>
+#include <mutex>
+
+#include "common/logging/log.h"
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
+#include "core/arm/unicorn/arm_unicorn.h"
+#include "core/core_cpu.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/hle/kernel/thread.h"
+#include "core/settings.h"
+
+namespace Core {
+
+void CpuBarrier::NotifyEnd() {
+    std::unique_lock<std::mutex> lock(mutex);
+    end = true;
+    condition.notify_all();
+}
+
+bool CpuBarrier::Rendezvous() {
+    if (!Settings::values.use_multi_core) {
+        // Meaningless when running in single-core mode
+        return true;
+    }
+
+    if (!end) {
+        std::unique_lock<std::mutex> lock(mutex);
+
+        --cores_waiting;
+        if (!cores_waiting) {
+            cores_waiting = NUM_CPU_CORES;
+            condition.notify_all();
+            return true;
+        }
+
+        condition.wait(lock);
+        return true;
+    }
+
+    return false;
+}
+
+Cpu::Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
+    : cpu_barrier{std::move(cpu_barrier)}, core_index{core_index} {
+
+    if (Settings::values.use_cpu_jit) {
+#ifdef ARCHITECTURE_x86_64
+        arm_interface = std::make_shared<ARM_Dynarmic>();
+#else
+        cpu_core = std::make_shared<ARM_Unicorn>();
+        LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+#endif
+    } else {
+        arm_interface = std::make_shared<ARM_Unicorn>();
+    }
+
+    scheduler = std::make_shared<Kernel::Scheduler>(arm_interface.get());
+}
+
+void Cpu::RunLoop(bool tight_loop) {
+    // Wait for all other CPU cores to complete the previous slice, such that they run in lock-step
+    if (!cpu_barrier->Rendezvous()) {
+        // If rendezvous failed, session has been killed
+        return;
+    }
+
+    // If we don't have a currently active thread then don't execute instructions,
+    // instead advance to the next event and try to yield to the next thread
+    if (Kernel::GetCurrentThread() == nullptr) {
+        LOG_TRACE(Core, "Core-{} idling", core_index);
+
+        if (IsMainCore()) {
+            CoreTiming::Idle();
+            CoreTiming::Advance();
+        }
+
+        PrepareReschedule();
+    } else {
+        if (IsMainCore()) {
+            CoreTiming::Advance();
+        }
+
+        if (tight_loop) {
+            arm_interface->Run();
+        } else {
+            arm_interface->Step();
+        }
+    }
+
+    Reschedule();
+}
+
+void Cpu::SingleStep() {
+    return RunLoop(false);
+}
+
+void Cpu::PrepareReschedule() {
+    arm_interface->PrepareReschedule();
+    reschedule_pending = true;
+}
+
+void Cpu::Reschedule() {
+    if (!reschedule_pending) {
+        return;
+    }
+
+    reschedule_pending = false;
+    scheduler->Reschedule();
+}
+
+} // namespace Core

src/core/core_cpu.h

@@ -0,0 +1,78 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <string>
+#include "common/common_types.h"
+
+class ARM_Interface;
+
+namespace Kernel {
+class Scheduler;
+}
+
+namespace Core {
+
+constexpr unsigned NUM_CPU_CORES{4};
+
+class CpuBarrier {
+public:
+    bool IsAlive() const {
+        return !end;
+    }
+
+    void NotifyEnd();
+
+    bool Rendezvous();
+
+private:
+    unsigned cores_waiting{NUM_CPU_CORES};
+    std::mutex mutex;
+    std::condition_variable condition;
+    std::atomic<bool> end{};
+};
+
+class Cpu {
+public:
+    Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
+
+    void RunLoop(bool tight_loop = true);
+
+    void SingleStep();
+
+    void PrepareReschedule();
+
+    ARM_Interface& ArmInterface() {
+        return *arm_interface;
+    }
+
+    const ARM_Interface& ArmInterface() const {
+        return *arm_interface;
+    }
+
+    const std::shared_ptr<Kernel::Scheduler>& Scheduler() const {
+        return scheduler;
+    }
+
+    bool IsMainCore() const {
+        return core_index == 0;
+    }
+
+private:
+    void Reschedule();
+
+    std::shared_ptr<ARM_Interface> arm_interface;
+    std::shared_ptr<CpuBarrier> cpu_barrier;
+    std::shared_ptr<Kernel::Scheduler> scheduler;
+
+    bool reschedule_pending{};
+    size_t core_index;
+};
+
+} // namespace Core

src/core/core_timing.cpp

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <cinttypes>
+#include <limits>
 #include <mutex>
 #include <string>
 #include <tuple>
@@ -57,7 +58,8 @@ static u64 event_fifo_id;
 // to the event_queue by the emu thread
 static Common::MPSCQueue<Event, false> ts_queue;
 
-static constexpr int MAX_SLICE_LENGTH = 20000;
+constexpr int MAX_SLICE_LENGTH = 20000;
+constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
 static s64 idled_cycles;
 
@@ -70,11 +72,59 @@ static EventType* ev_lost = nullptr;
 
 static void EmptyTimedCallback(u64 userdata, s64 cyclesLate) {}
 
+s64 usToCycles(s64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * us) / 1000000;
+}
+
+s64 usToCycles(u64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
+}
+
+s64 nsToCycles(s64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (ns / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * ns) / 1000000000;
+}
+
+s64 nsToCycles(u64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
+}
+
 EventType* RegisterEvent(const std::string& name, TimedCallback callback) {
     // check for existing type with same name.
     // we want event type names to remain unique so that we can use them for serialization.
     ASSERT_MSG(event_types.find(name) == event_types.end(),
-               "CoreTiming Event \"%s\" is already registered. Events should only be registered "
+               "CoreTiming Event \"{}\" is already registered. Events should only be registered "
                "during Init to avoid breaking save states.",
                name.c_str());
 

src/core/core_timing.h

@@ -18,15 +18,14 @@
  */
 
 #include <functional>
-#include <limits>
 #include <string>
 #include "common/common_types.h"
-#include "common/logging/log.h"
+
+namespace CoreTiming {
 
 // The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
 // The exact value used is of course unverified.
 constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
-constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
 inline s64 msToCycles(int ms) {
     // since ms is int there is no way to overflow
@@ -49,29 +48,9 @@ inline s64 usToCycles(int us) {
     return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
 }
 
-inline s64 usToCycles(s64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * us) / 1000000;
-}
+s64 usToCycles(s64 us);
 
-inline s64 usToCycles(u64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
-}
+s64 usToCycles(u64 us);
 
 inline s64 nsToCycles(float ns) {
     return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
@@ -81,29 +60,9 @@ inline s64 nsToCycles(int ns) {
     return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
 }
 
-inline s64 nsToCycles(s64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ns / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * ns) / 1000000000;
-}
+s64 nsToCycles(s64 ns);
 
-inline s64 nsToCycles(u64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
-}
+s64 nsToCycles(u64 ns);
 
 inline u64 cyclesToNs(s64 cycles) {
     return cycles * 1000000000 / BASE_CLOCK_RATE;
@@ -117,8 +76,6 @@ inline u64 cyclesToMs(s64 cycles) {
     return cycles * 1000 / BASE_CLOCK_RATE;
 }
 
-namespace CoreTiming {
-
 /**
  * CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
  * required to end slice -1 and start slice 0 before the first cycle of code is executed.

src/core/file_sys/content_archive.cpp

@@ -0,0 +1,167 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/vfs_offset.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+// Media offsets in headers are stored divided by 512. Mult. by this to get real offset.
+constexpr u64 MEDIA_OFFSET_MULTIPLIER = 0x200;
+
+constexpr u64 SECTION_HEADER_SIZE = 0x200;
+constexpr u64 SECTION_HEADER_OFFSET = 0x400;
+
+constexpr u32 IVFC_MAX_LEVEL = 6;
+
+enum class NCASectionFilesystemType : u8 {
+    PFS0 = 0x2,
+    ROMFS = 0x3,
+};
+
+struct NCASectionHeaderBlock {
+    INSERT_PADDING_BYTES(3);
+    NCASectionFilesystemType filesystem_type;
+    u8 crypto_type;
+    INSERT_PADDING_BYTES(3);
+};
+static_assert(sizeof(NCASectionHeaderBlock) == 0x8, "NCASectionHeaderBlock has incorrect size.");
+
+struct PFS0Superblock {
+    NCASectionHeaderBlock header_block;
+    std::array<u8, 0x20> hash;
+    u32_le size;
+    INSERT_PADDING_BYTES(4);
+    u64_le hash_table_offset;
+    u64_le hash_table_size;
+    u64_le pfs0_header_offset;
+    u64_le pfs0_size;
+    INSERT_PADDING_BYTES(432);
+};
+static_assert(sizeof(PFS0Superblock) == 0x200, "PFS0Superblock has incorrect size.");
+
+struct IVFCLevel {
+    u64_le offset;
+    u64_le size;
+    u32_le block_size;
+    u32_le reserved;
+};
+static_assert(sizeof(IVFCLevel) == 0x18, "IVFCLevel has incorrect size.");
+
+struct RomFSSuperblock {
+    NCASectionHeaderBlock header_block;
+    u32_le magic;
+    u32_le magic_number;
+    INSERT_PADDING_BYTES(8);
+    std::array<IVFCLevel, 6> levels;
+    INSERT_PADDING_BYTES(64);
+};
+static_assert(sizeof(RomFSSuperblock) == 0xE8, "RomFSSuperblock has incorrect size.");
+
+NCA::NCA(VirtualFile file_) : file(file_) {
+    if (sizeof(NCAHeader) != file->ReadObject(&header))
+        LOG_CRITICAL(Loader, "File reader errored out during header read.");
+
+    if (!IsValidNCA(header)) {
+        status = Loader::ResultStatus::ErrorInvalidFormat;
+        return;
+    }
+
+    std::ptrdiff_t number_sections =
+        std::count_if(std::begin(header.section_tables), std::end(header.section_tables),
+                      [](NCASectionTableEntry entry) { return entry.media_offset > 0; });
+
+    for (std::ptrdiff_t i = 0; i < number_sections; ++i) {
+        // Seek to beginning of this section.
+        NCASectionHeaderBlock block{};
+        if (sizeof(NCASectionHeaderBlock) !=
+            file->ReadObject(&block, SECTION_HEADER_OFFSET + i * SECTION_HEADER_SIZE))
+            LOG_CRITICAL(Loader, "File reader errored out during header read.");
+
+        if (block.filesystem_type == NCASectionFilesystemType::ROMFS) {
+            RomFSSuperblock sb{};
+            if (sizeof(RomFSSuperblock) !=
+                file->ReadObject(&sb, SECTION_HEADER_OFFSET + i * SECTION_HEADER_SIZE))
+                LOG_CRITICAL(Loader, "File reader errored out during header read.");
+
+            const size_t romfs_offset =
+                header.section_tables[i].media_offset * MEDIA_OFFSET_MULTIPLIER +
+                sb.levels[IVFC_MAX_LEVEL - 1].offset;
+            const size_t romfs_size = sb.levels[IVFC_MAX_LEVEL - 1].size;
+            files.emplace_back(std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset));
+            romfs = files.back();
+        } else if (block.filesystem_type == NCASectionFilesystemType::PFS0) {
+            PFS0Superblock sb{};
+            // Seek back to beginning of this section.
+            if (sizeof(PFS0Superblock) !=
+                file->ReadObject(&sb, SECTION_HEADER_OFFSET + i * SECTION_HEADER_SIZE))
+                LOG_CRITICAL(Loader, "File reader errored out during header read.");
+
+            u64 offset = (static_cast<u64>(header.section_tables[i].media_offset) *
+                          MEDIA_OFFSET_MULTIPLIER) +
+                         sb.pfs0_header_offset;
+            u64 size = MEDIA_OFFSET_MULTIPLIER * (header.section_tables[i].media_end_offset -
+                                                  header.section_tables[i].media_offset);
+            auto npfs = std::make_shared<PartitionFilesystem>(
+                std::make_shared<OffsetVfsFile>(file, size, offset));
+
+            if (npfs->GetStatus() == Loader::ResultStatus::Success) {
+                dirs.emplace_back(npfs);
+                if (IsDirectoryExeFS(dirs.back()))
+                    exefs = dirs.back();
+            }
+        }
+    }
+
+    status = Loader::ResultStatus::Success;
+}
+
+Loader::ResultStatus NCA::GetStatus() const {
+    return status;
+}
+
+std::vector<std::shared_ptr<VfsFile>> NCA::GetFiles() const {
+    if (status != Loader::ResultStatus::Success)
+        return {};
+    return files;
+}
+
+std::vector<std::shared_ptr<VfsDirectory>> NCA::GetSubdirectories() const {
+    if (status != Loader::ResultStatus::Success)
+        return {};
+    return dirs;
+}
+
+std::string NCA::GetName() const {
+    return file->GetName();
+}
+
+std::shared_ptr<VfsDirectory> NCA::GetParentDirectory() const {
+    return file->GetContainingDirectory();
+}
+
+NCAContentType NCA::GetType() const {
+    return header.content_type;
+}
+
+u64 NCA::GetTitleId() const {
+    if (status != Loader::ResultStatus::Success)
+        return {};
+    return header.title_id;
+}
+
+VirtualFile NCA::GetRomFS() const {
+    return romfs;
+}
+
+VirtualDir NCA::GetExeFS() const {
+    return exefs;
+}
+
+bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+} // namespace FileSys

src/core/file_sys/content_archive.h

@@ -0,0 +1,95 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/file_sys/partition_filesystem.h"
+
+namespace FileSys {
+
+enum class NCAContentType : u8 {
+    Program = 0,
+    Meta = 1,
+    Control = 2,
+    Manual = 3,
+    Data = 4,
+};
+
+struct NCASectionTableEntry {
+    u32_le media_offset;
+    u32_le media_end_offset;
+    INSERT_PADDING_BYTES(0x8);
+};
+static_assert(sizeof(NCASectionTableEntry) == 0x10, "NCASectionTableEntry has incorrect size.");
+
+struct NCAHeader {
+    std::array<u8, 0x100> rsa_signature_1;
+    std::array<u8, 0x100> rsa_signature_2;
+    u32_le magic;
+    u8 is_system;
+    NCAContentType content_type;
+    u8 crypto_type;
+    u8 key_index;
+    u64_le size;
+    u64_le title_id;
+    INSERT_PADDING_BYTES(0x4);
+    u32_le sdk_version;
+    u8 crypto_type_2;
+    INSERT_PADDING_BYTES(15);
+    std::array<u8, 0x10> rights_id;
+    std::array<NCASectionTableEntry, 0x4> section_tables;
+    std::array<std::array<u8, 0x20>, 0x4> hash_tables;
+    std::array<std::array<u8, 0x10>, 0x4> key_area;
+    INSERT_PADDING_BYTES(0xC0);
+};
+static_assert(sizeof(NCAHeader) == 0x400, "NCAHeader has incorrect size.");
+
+inline bool IsDirectoryExeFS(std::shared_ptr<FileSys::VfsDirectory> pfs) {
+    // According to switchbrew, an exefs must only contain these two files:
+    return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
+}
+
+inline bool IsValidNCA(const NCAHeader& header) {
+    return header.magic == Common::MakeMagic('N', 'C', 'A', '2') ||
+           header.magic == Common::MakeMagic('N', 'C', 'A', '3');
+}
+
+// An implementation of VfsDirectory that represents a Nintendo Content Archive (NCA) conatiner.
+// After construction, use GetStatus to determine if the file is valid and ready to be used.
+class NCA : public ReadOnlyVfsDirectory {
+public:
+    explicit NCA(VirtualFile file);
+    Loader::ResultStatus GetStatus() const;
+
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::string GetName() const override;
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+
+    NCAContentType GetType() const;
+    u64 GetTitleId() const;
+
+    VirtualFile GetRomFS() const;
+    VirtualDir GetExeFS() const;
+
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
+private:
+    std::vector<VirtualDir> dirs;
+    std::vector<VirtualFile> files;
+
+    VirtualFile romfs = nullptr;
+    VirtualDir exefs = nullptr;
+    VirtualFile file;
+
+    NCAHeader header{};
+
+    Loader::ResultStatus status{};
+};
+
+} // namespace FileSys

src/core/file_sys/directory.h

@@ -8,13 +8,17 @@
 #include <cstddef>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // FileSys namespace
 
 namespace FileSys {
 
+enum EntryType : u8 {
+    Directory = 0,
+    File = 1,
+};
+
 // Structure of a directory entry, from
 // http://switchbrew.org/index.php?title=Filesystem_services#DirectoryEntry
 const size_t FILENAME_LENGTH = 0x300;

src/core/file_sys/disk_filesystem.cpp

@@ -1,232 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <memory>
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/file_sys/disk_filesystem.h"
-#include "core/file_sys/errors.h"
-
-namespace FileSys {
-
-static std::string ModeFlagsToString(Mode mode) {
-    std::string mode_str;
-    u32 mode_flags = static_cast<u32>(mode);
-
-    // Calculate the correct open mode for the file.
-    if ((mode_flags & static_cast<u32>(Mode::Read)) &&
-        (mode_flags & static_cast<u32>(Mode::Write))) {
-        if (mode_flags & static_cast<u32>(Mode::Append))
-            mode_str = "a+";
-        else
-            mode_str = "r+";
-    } else {
-        if (mode_flags & static_cast<u32>(Mode::Read))
-            mode_str = "r";
-        else if (mode_flags & static_cast<u32>(Mode::Append))
-            mode_str = "a";
-        else if (mode_flags & static_cast<u32>(Mode::Write))
-            mode_str = "w";
-    }
-
-    mode_str += "b";
-
-    return mode_str;
-}
-
-std::string Disk_FileSystem::GetName() const {
-    return "Disk";
-}
-
-ResultVal<std::unique_ptr<StorageBackend>> Disk_FileSystem::OpenFile(const std::string& path,
-                                                                     Mode mode) const {
-
-    // Calculate the correct open mode for the file.
-    std::string mode_str = ModeFlagsToString(mode);
-
-    std::string full_path = base_directory + path;
-    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode_str.c_str());
-
-    if (!file->IsOpen()) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    return MakeResult<std::unique_ptr<StorageBackend>>(
-        std::make_unique<Disk_Storage>(std::move(file)));
-}
-
-ResultCode Disk_FileSystem::DeleteFile(const std::string& path) const {
-    if (!FileUtil::Exists(path)) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    FileUtil::Delete(path);
-
-    return RESULT_SUCCESS;
-}
-
-ResultCode Disk_FileSystem::RenameFile(const Path& src_path, const Path& dest_path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectory(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectoryRecursively(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-
-    std::string full_path = base_directory + path;
-    if (size == 0) {
-        FileUtil::CreateEmptyFile(full_path);
-        return RESULT_SUCCESS;
-    }
-
-    FileUtil::IOFile file(full_path, "wb");
-    // Creates a sparse file (or a normal file on filesystems without the concept of sparse files)
-    // We do this by seeking to the right size, then writing a single null byte.
-    if (file.Seek(size - 1, SEEK_SET) && file.WriteBytes("", 1) == 1) {
-        return RESULT_SUCCESS;
-    }
-
-    LOG_ERROR(Service_FS, "Too large file");
-    // TODO(Subv): Find out the correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::CreateDirectory(const std::string& path) const {
-    // TODO(Subv): Perform path validation to prevent escaping the emulator sandbox.
-    std::string full_path = base_directory + path;
-
-    if (FileUtil::CreateDir(full_path)) {
-        return RESULT_SUCCESS;
-    }
-
-    LOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating %s", full_path.c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultVal<std::unique_ptr<DirectoryBackend>> Disk_FileSystem::OpenDirectory(
-    const std::string& path) const {
-
-    std::string full_path = base_directory + path;
-
-    if (!FileUtil::IsDirectory(full_path)) {
-        // TODO(Subv): Find the correct error code for this.
-        return ResultCode(-1);
-    }
-
-    auto directory = std::make_unique<Disk_Directory>(full_path);
-    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::move(directory));
-}
-
-u64 Disk_FileSystem::GetFreeSpaceSize() const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return 0;
-}
-
-ResultVal<FileSys::EntryType> Disk_FileSystem::GetEntryType(const std::string& path) const {
-    std::string full_path = base_directory + path;
-    if (!FileUtil::Exists(full_path)) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    if (FileUtil::IsDirectory(full_path))
-        return MakeResult(EntryType::Directory);
-
-    return MakeResult(EntryType::File);
-}
-
-ResultVal<size_t> Disk_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
-    LOG_TRACE(Service_FS, "called offset=%llu, length=%zu", offset, length);
-    file->Seek(offset, SEEK_SET);
-    return MakeResult<size_t>(file->ReadBytes(buffer, length));
-}
-
-ResultVal<size_t> Disk_Storage::Write(const u64 offset, const size_t length, const bool flush,
-                                      const u8* buffer) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    file->Seek(offset, SEEK_SET);
-    size_t written = file->WriteBytes(buffer, length);
-    if (flush) {
-        file->Flush();
-    }
-    return MakeResult<size_t>(written);
-}
-
-u64 Disk_Storage::GetSize() const {
-    return file->GetSize();
-}
-
-bool Disk_Storage::SetSize(const u64 size) const {
-    file->Resize(size);
-    file->Flush();
-    return true;
-}
-
-Disk_Directory::Disk_Directory(const std::string& path) : directory() {
-    unsigned size = FileUtil::ScanDirectoryTree(path, directory);
-    directory.size = size;
-    directory.isDirectory = true;
-    children_iterator = directory.children.begin();
-}
-
-u64 Disk_Directory::Read(const u64 count, Entry* entries) {
-    u64 entries_read = 0;
-
-    while (entries_read < count && children_iterator != directory.children.cend()) {
-        const FileUtil::FSTEntry& file = *children_iterator;
-        const std::string& filename = file.virtualName;
-        Entry& entry = entries[entries_read];
-
-        LOG_TRACE(Service_FS, "File %s: size=%llu dir=%d", filename.c_str(), file.size,
-                  file.isDirectory);
-
-        // TODO(Link Mauve): use a proper conversion to UTF-16.
-        for (size_t j = 0; j < FILENAME_LENGTH; ++j) {
-            entry.filename[j] = filename[j];
-            if (!filename[j])
-                break;
-        }
-
-        if (file.isDirectory) {
-            entry.file_size = 0;
-            entry.type = EntryType::Directory;
-        } else {
-            entry.file_size = file.size;
-            entry.type = EntryType::File;
-        }
-
-        ++entries_read;
-        ++children_iterator;
-    }
-    return entries_read;
-}
-
-u64 Disk_Directory::GetEntryCount() const {
-    // We convert the children iterator into a const_iterator to allow template argument deduction
-    // in std::distance.
-    std::vector<FileUtil::FSTEntry>::const_iterator current = children_iterator;
-    return std::distance(current, directory.children.end());
-}
-
-} // namespace FileSys

src/core/file_sys/disk_filesystem.h

@@ -1,85 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "common/file_util.h"
-#include "core/file_sys/directory.h"
-#include "core/file_sys/filesystem.h"
-#include "core/file_sys/storage.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class Disk_FileSystem : public FileSystemBackend {
-public:
-    explicit Disk_FileSystem(std::string base_directory)
-        : base_directory(std::move(base_directory)) {}
-
-    std::string GetName() const override;
-
-    ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                        Mode mode) const override;
-    ResultCode DeleteFile(const std::string& path) const override;
-    ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
-    ResultCode DeleteDirectory(const Path& path) const override;
-    ResultCode DeleteDirectoryRecursively(const Path& path) const override;
-    ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const std::string& path) const override;
-    ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const override;
-    u64 GetFreeSpaceSize() const override;
-    ResultVal<EntryType> GetEntryType(const std::string& path) const override;
-
-protected:
-    std::string base_directory;
-};
-
-class Disk_Storage : public StorageBackend {
-public:
-    Disk_Storage(std::shared_ptr<FileUtil::IOFile> file) : file(std::move(file)) {}
-
-    ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const override;
-    ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const override;
-    u64 GetSize() const override;
-    bool SetSize(u64 size) const override;
-    bool Close() const override {
-        return false;
-    }
-    void Flush() const override {}
-
-private:
-    std::shared_ptr<FileUtil::IOFile> file;
-};
-
-class Disk_Directory : public DirectoryBackend {
-public:
-    Disk_Directory(const std::string& path);
-
-    ~Disk_Directory() override {
-        Close();
-    }
-
-    u64 Read(const u64 count, Entry* entries) override;
-    u64 GetEntryCount() const override;
-
-    bool Close() const override {
-        return true;
-    }
-
-protected:
-    u32 total_entries_in_directory;
-    FileUtil::FSTEntry directory;
-
-    // We need to remember the last entry we returned, so a subsequent call to Read will continue
-    // from the next one. This iterator will always point to the next unread entry.
-    std::vector<FileUtil::FSTEntry>::iterator children_iterator;
-};
-
-} // namespace FileSys

src/core/file_sys/errors.h

@@ -11,6 +11,9 @@ namespace FileSys {
 namespace ErrCodes {
 enum {
     NotFound = 1,
+    TitleNotFound = 1002,
+    SdCardNotFound = 2001,
+    RomFSNotFound = 2520,
 };
 }
 

src/core/file_sys/filesystem.cpp

@@ -1,122 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstddef>
-#include <iomanip>
-#include <sstream>
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/file_sys/filesystem.h"
-#include "core/memory.h"
-
-namespace FileSys {
-
-Path::Path(LowPathType type, u32 size, u32 pointer) : type(type) {
-    switch (type) {
-    case Binary: {
-        binary.resize(size);
-        Memory::ReadBlock(pointer, binary.data(), binary.size());
-        break;
-    }
-
-    case Char: {
-        string.resize(size - 1); // Data is always null-terminated.
-        Memory::ReadBlock(pointer, &string[0], string.size());
-        break;
-    }
-
-    case Wchar: {
-        u16str.resize(size / 2 - 1); // Data is always null-terminated.
-        Memory::ReadBlock(pointer, &u16str[0], u16str.size() * sizeof(char16_t));
-        break;
-    }
-
-    default:
-        break;
-    }
-}
-
-std::string Path::DebugStr() const {
-    switch (GetType()) {
-    case Invalid:
-    default:
-        return "[Invalid]";
-    case Empty:
-        return "[Empty]";
-    case Binary: {
-        std::stringstream res;
-        res << "[Binary: ";
-        for (unsigned byte : binary)
-            res << std::hex << std::setw(2) << std::setfill('0') << byte;
-        res << ']';
-        return res.str();
-    }
-    case Char:
-        return "[Char: " + AsString() + ']';
-    case Wchar:
-        return "[Wchar: " + AsString() + ']';
-    }
-}
-
-std::string Path::AsString() const {
-    switch (GetType()) {
-    case Char:
-        return string;
-    case Wchar:
-        return Common::UTF16ToUTF8(u16str);
-    case Empty:
-        return {};
-    case Invalid:
-    case Binary:
-    default:
-        // TODO(yuriks): Add assert
-        LOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
-        return {};
-    }
-}
-
-std::u16string Path::AsU16Str() const {
-    switch (GetType()) {
-    case Char:
-        return Common::UTF8ToUTF16(string);
-    case Wchar:
-        return u16str;
-    case Empty:
-        return {};
-    case Invalid:
-    case Binary:
-        // TODO(yuriks): Add assert
-        LOG_ERROR(Service_FS, "LowPathType cannot be converted to u16string!");
-        return {};
-    }
-
-    UNREACHABLE();
-}
-
-std::vector<u8> Path::AsBinary() const {
-    switch (GetType()) {
-    case Binary:
-        return binary;
-    case Char:
-        return std::vector<u8>(string.begin(), string.end());
-    case Wchar: {
-        // use two u8 for each character of u16str
-        std::vector<u8> to_return(u16str.size() * 2);
-        for (size_t i = 0; i < u16str.size(); ++i) {
-            u16 tmp_char = u16str.at(i);
-            to_return[i * 2] = (tmp_char & 0xFF00) >> 8;
-            to_return[i * 2 + 1] = (tmp_char & 0x00FF);
-        }
-        return to_return;
-    }
-    case Empty:
-        return {};
-    case Invalid:
-    default:
-        // TODO(yuriks): Add assert
-        LOG_ERROR(Service_FS, "LowPathType cannot be converted to binary!");
-        return {};
-    }
-}
-} // namespace FileSys

src/core/file_sys/filesystem.h

@@ -1,200 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class StorageBackend;
-class DirectoryBackend;
-
-// Path string type
-enum LowPathType : u32 {
-    Invalid = 0,
-    Empty = 1,
-    Binary = 2,
-    Char = 3,
-    Wchar = 4,
-};
-
-enum EntryType : u8 {
-    Directory = 0,
-    File = 1,
-};
-
-enum class Mode : u32 {
-    Read = 1,
-    Write = 2,
-    Append = 4,
-};
-
-class Path {
-public:
-    Path() : type(Invalid) {}
-    Path(const char* path) : type(Char), string(path) {}
-    Path(std::vector<u8> binary_data) : type(Binary), binary(std::move(binary_data)) {}
-    Path(LowPathType type, u32 size, u32 pointer);
-
-    LowPathType GetType() const {
-        return type;
-    }
-
-    /**
-     * Gets the string representation of the path for debugging
-     * @return String representation of the path for debugging
-     */
-    std::string DebugStr() const;
-
-    std::string AsString() const;
-    std::u16string AsU16Str() const;
-    std::vector<u8> AsBinary() const;
-
-private:
-    LowPathType type;
-    std::vector<u8> binary;
-    std::string string;
-    std::u16string u16str;
-};
-
-/// Parameters of the archive, as specified in the Create or Format call.
-struct ArchiveFormatInfo {
-    u32_le total_size;         ///< The pre-defined size of the archive.
-    u32_le number_directories; ///< The pre-defined number of directories in the archive.
-    u32_le number_files;       ///< The pre-defined number of files in the archive.
-    u8 duplicate_data;         ///< Whether the archive should duplicate the data.
-};
-static_assert(std::is_pod<ArchiveFormatInfo>::value, "ArchiveFormatInfo is not POD");
-
-class FileSystemBackend : NonCopyable {
-public:
-    virtual ~FileSystemBackend() {}
-
-    /**
-     * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
-     */
-    virtual std::string GetName() const = 0;
-
-    /**
-     * Create a file specified by its path
-     * @param path Path relative to the Archive
-     * @param size The size of the new file, filled with zeroes
-     * @return Result of the operation
-     */
-    virtual ResultCode CreateFile(const std::string& path, u64 size) const = 0;
-
-    /**
-     * Delete a file specified by its path
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode DeleteFile(const std::string& path) const = 0;
-
-    /**
-     * Create a directory specified by its path
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode CreateDirectory(const std::string& path) const = 0;
-
-    /**
-     * Delete a directory specified by its path
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode DeleteDirectory(const Path& path) const = 0;
-
-    /**
-     * Delete a directory specified by its path and anything under it
-     * @param path Path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode DeleteDirectoryRecursively(const Path& path) const = 0;
-
-    /**
-     * Rename a File specified by its path
-     * @param src_path Source path relative to the archive
-     * @param dest_path Destination path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode RenameFile(const Path& src_path, const Path& dest_path) const = 0;
-
-    /**
-     * Rename a Directory specified by its path
-     * @param src_path Source path relative to the archive
-     * @param dest_path Destination path relative to the archive
-     * @return Result of the operation
-     */
-    virtual ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const = 0;
-
-    /**
-     * Open a file specified by its path, using the specified mode
-     * @param path Path relative to the archive
-     * @param mode Mode to open the file with
-     * @return Opened file, or error code
-     */
-    virtual ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                                Mode mode) const = 0;
-
-    /**
-     * Open a directory specified by its path
-     * @param path Path relative to the archive
-     * @return Opened directory, or error code
-     */
-    virtual ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const = 0;
-
-    /**
-     * Get the free space
-     * @return The number of free bytes in the archive
-     */
-    virtual u64 GetFreeSpaceSize() const = 0;
-
-    /**
-     * Get the type of the specified path
-     * @return The type of the specified path or error code
-     */
-    virtual ResultVal<EntryType> GetEntryType(const std::string& path) const = 0;
-};
-
-class FileSystemFactory : NonCopyable {
-public:
-    virtual ~FileSystemFactory() {}
-
-    /**
-     * Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
-     */
-    virtual std::string GetName() const = 0;
-
-    /**
-     * Tries to open the archive of this type with the specified path
-     * @param path Path to the archive
-     * @return An ArchiveBackend corresponding operating specified archive path.
-     */
-    virtual ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) = 0;
-
-    /**
-     * Deletes the archive contents and then re-creates the base folder
-     * @param path Path to the archive
-     * @return ResultCode of the operation, 0 on success
-     */
-    virtual ResultCode Format(const Path& path) = 0;
-
-    /**
-     * Retrieves the format info about the archive with the specified path
-     * @param path Path to the archive
-     * @return Format information about the archive or error code
-     */
-    virtual ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const = 0;
-};
-
-} // namespace FileSys

src/core/file_sys/mode.h

@@ -0,0 +1,17 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace FileSys {
+
+enum class Mode : u32 {
+    Read = 1,
+    Write = 2,
+    Append = 4,
+};
+
+} // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -2,124 +2,123 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
 #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"
 #include "core/loader/loader.h"
 
 namespace FileSys {
 
-Loader::ResultStatus PartitionFilesystem::Load(const std::string& file_path, size_t offset) {
-    FileUtil::IOFile file(file_path, "rb");
-    if (!file.IsOpen())
-        return Loader::ResultStatus::Error;
-
+PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     // At least be as large as the header
-    if (file.GetSize() < sizeof(Header))
-        return Loader::ResultStatus::Error;
+    if (file->GetSize() < sizeof(Header)) {
+        status = Loader::ResultStatus::Error;
+        return;
+    }
 
     // For cartridges, HFSs can get very large, so we need to calculate the size up to
     // the actual content itself instead of just blindly reading in the entire file.
     Header pfs_header;
-    if (!file.ReadBytes(&pfs_header, sizeof(Header)))
-        return Loader::ResultStatus::Error;
+    if (sizeof(Header) != file->ReadObject(&pfs_header)) {
+        status = Loader::ResultStatus::Error;
+        return;
+    }
+
+    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
+        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
+        status = Loader::ResultStatus::ErrorInvalidFormat;
+        return;
+    }
+
+    bool is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
 
-    bool is_hfs = (memcmp(pfs_header.magic.data(), "HFS", 3) == 0);
     size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
     size_t metadata_size =
         sizeof(Header) + (pfs_header.num_entries * entry_size) + pfs_header.strtab_size;
 
     // Actually read in now...
-    file.Seek(offset, SEEK_SET);
-    std::vector<u8> file_data(metadata_size);
+    std::vector<u8> file_data = file->ReadBytes(metadata_size);
 
-    if (!file.ReadBytes(file_data.data(), metadata_size))
-        return Loader::ResultStatus::Error;
+    if (file_data.size() != metadata_size) {
+        status = Loader::ResultStatus::Error;
+        return;
+    }
 
-    Loader::ResultStatus result = Load(file_data);
-    if (result != Loader::ResultStatus::Success)
-        LOG_ERROR(Service_FS, "Failed to load PFS from file %s!", file_path.c_str());
+    size_t total_size = file_data.size();
+    if (total_size < sizeof(Header)) {
+        status = Loader::ResultStatus::Error;
+        return;
+    }
 
-    return result;
-}
+    memcpy(&pfs_header, file_data.data(), sizeof(Header));
+    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
+        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
+        status = Loader::ResultStatus::ErrorInvalidFormat;
+        return;
+    }
 
-Loader::ResultStatus PartitionFilesystem::Load(const std::vector<u8>& file_data, size_t offset) {
-    size_t total_size = file_data.size() - offset;
-    if (total_size < sizeof(Header))
-        return Loader::ResultStatus::Error;
+    is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
 
-    memcpy(&pfs_header, &file_data[offset], sizeof(Header));
-    is_hfs = (memcmp(pfs_header.magic.data(), "HFS", 3) == 0);
-
-    size_t entries_offset = offset + sizeof(Header);
-    size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
+    size_t entries_offset = sizeof(Header);
     size_t strtab_offset = entries_offset + (pfs_header.num_entries * entry_size);
-    for (u16 i = 0; i < pfs_header.num_entries; i++) {
-        FileEntry entry;
-
-        memcpy(&entry.fs_entry, &file_data[entries_offset + (i * entry_size)], sizeof(FSEntry));
-        entry.name = std::string(reinterpret_cast<const char*>(
-            &file_data[strtab_offset + entry.fs_entry.strtab_offset]));
-        pfs_entries.push_back(std::move(entry));
-    }
-
     content_offset = strtab_offset + pfs_header.strtab_size;
+    for (u16 i = 0; i < pfs_header.num_entries; i++) {
+        FSEntry entry;
 
-    return Loader::ResultStatus::Success;
-}
+        memcpy(&entry, &file_data[entries_offset + (i * entry_size)], sizeof(FSEntry));
+        std::string name(
+            reinterpret_cast<const char*>(&file_data[strtab_offset + entry.strtab_offset]));
 
-u32 PartitionFilesystem::GetNumEntries() const {
-    return pfs_header.num_entries;
-}
-
-u64 PartitionFilesystem::GetEntryOffset(int index) const {
-    if (index > GetNumEntries())
-        return 0;
-
-    return content_offset + pfs_entries[index].fs_entry.offset;
-}
-
-u64 PartitionFilesystem::GetEntrySize(int index) const {
-    if (index > GetNumEntries())
-        return 0;
-
-    return pfs_entries[index].fs_entry.size;
-}
-
-std::string PartitionFilesystem::GetEntryName(int index) const {
-    if (index > GetNumEntries())
-        return "";
-
-    return pfs_entries[index].name;
-}
-
-u64 PartitionFilesystem::GetFileOffset(const std::string& name) const {
-    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        if (pfs_entries[i].name == name)
-            return content_offset + pfs_entries[i].fs_entry.offset;
+        pfs_files.emplace_back(
+            std::make_shared<OffsetVfsFile>(file, entry.size, content_offset + entry.offset, name));
     }
 
-    return 0;
+    status = Loader::ResultStatus::Success;
 }
 
-u64 PartitionFilesystem::GetFileSize(const std::string& name) const {
-    for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        if (pfs_entries[i].name == name)
-            return pfs_entries[i].fs_entry.size;
-    }
-
-    return 0;
+Loader::ResultStatus PartitionFilesystem::GetStatus() const {
+    return status;
 }
 
-void PartitionFilesystem::Print() const {
-    NGLOG_DEBUG(Service_FS, "Magic:                  {:.4}", pfs_header.magic.data());
-    NGLOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
+std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
+    return pfs_files;
+}
+
+std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
+    return {};
+}
+
+std::string PartitionFilesystem::GetName() const {
+    return is_hfs ? "HFS0" : "PFS0";
+}
+
+std::shared_ptr<VfsDirectory> PartitionFilesystem::GetParentDirectory() const {
+    // TODO(DarkLordZach): Add support for nested containers.
+    return nullptr;
+}
+
+void PartitionFilesystem::PrintDebugInfo() const {
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", pfs_header.magic);
+    LOG_DEBUG(Service_FS, "Files:                  {}", pfs_header.num_entries);
     for (u32 i = 0; i < pfs_header.num_entries; i++) {
-        NGLOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes, at 0x{:X})", i,
-                    pfs_entries[i].name.c_str(), pfs_entries[i].fs_entry.size,
-                    GetFileOffset(pfs_entries[i].name));
+        LOG_DEBUG(Service_FS, " > File {}:              {} (0x{:X} bytes, at 0x{:X})", i,
+                  pfs_files[i]->GetName(), pfs_files[i]->GetSize(),
+                  dynamic_cast<OffsetVfsFile*>(pfs_files[i].get())->GetOffset());
     }
 }
+
+bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
+    if (iter == pfs_files.end())
+        return false;
+
+    pfs_files[iter - pfs_files.begin()] = pfs_files.back();
+    pfs_files.pop_back();
+
+    pfs_dirs.emplace_back(dir);
+
+    return true;
+}
 } // namespace FileSys

src/core/file_sys/partition_filesystem.h

@@ -10,6 +10,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/file_sys/vfs.h"
 
 namespace Loader {
 enum class ResultStatus;
@@ -21,23 +22,23 @@ namespace FileSys {
  * Helper which implements an interface to parse PFS/HFS filesystems.
  * Data can either be loaded from a file path or data with an offset into it.
  */
-class PartitionFilesystem {
+class PartitionFilesystem : public ReadOnlyVfsDirectory {
 public:
-    Loader::ResultStatus Load(const std::string& file_path, size_t offset = 0);
-    Loader::ResultStatus Load(const std::vector<u8>& file_data, size_t offset = 0);
+    explicit PartitionFilesystem(std::shared_ptr<VfsFile> file);
+    Loader::ResultStatus GetStatus() const;
 
-    u32 GetNumEntries() const;
-    u64 GetEntryOffset(int index) const;
-    u64 GetEntrySize(int index) const;
-    std::string GetEntryName(int index) const;
-    u64 GetFileOffset(const std::string& name) const;
-    u64 GetFileSize(const std::string& name) const;
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::string GetName() const override;
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    void PrintDebugInfo() const;
 
-    void Print() const;
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
 
 private:
     struct Header {
-        std::array<char, 4> magic;
+        u32_le magic;
         u32_le num_entries;
         u32_le strtab_size;
         INSERT_PADDING_BYTES(0x4);
@@ -72,16 +73,14 @@ private:
 
 #pragma pack(pop)
 
-    struct FileEntry {
-        FSEntry fs_entry;
-        std::string name;
-    };
+    Loader::ResultStatus status;
 
     Header pfs_header;
     bool is_hfs;
     size_t content_offset;
 
-    std::vector<FileEntry> pfs_entries;
+    std::vector<VirtualFile> pfs_files;
+    std::vector<VirtualDir> pfs_dirs;
 };
 
 } // namespace FileSys

src/core/file_sys/path_parser.cpp

@@ -1,98 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <set>
-#include "common/file_util.h"
-#include "common/string_util.h"
-#include "core/file_sys/path_parser.h"
-
-namespace FileSys {
-
-PathParser::PathParser(const Path& path) {
-    if (path.GetType() != LowPathType::Char && path.GetType() != LowPathType::Wchar) {
-        is_valid = false;
-        return;
-    }
-
-    auto path_string = path.AsString();
-    if (path_string.size() == 0 || path_string[0] != '/') {
-        is_valid = false;
-        return;
-    }
-
-    // Filter out invalid characters for the host system.
-    // Although some of these characters are valid on 3DS, they are unlikely to be used by games.
-    if (std::find_if(path_string.begin(), path_string.end(), [](char c) {
-            static const std::set<char> invalid_chars{'<', '>', '\\', '|', ':', '\"', '*', '?'};
-            return invalid_chars.find(c) != invalid_chars.end();
-        }) != path_string.end()) {
-        is_valid = false;
-        return;
-    }
-
-    Common::SplitString(path_string, '/', path_sequence);
-
-    auto begin = path_sequence.begin();
-    auto end = path_sequence.end();
-    end = std::remove_if(begin, end, [](std::string& str) { return str == "" || str == "."; });
-    path_sequence = std::vector<std::string>(begin, end);
-
-    // checks if the path is out of bounds.
-    int level = 0;
-    for (auto& node : path_sequence) {
-        if (node == "..") {
-            --level;
-            if (level < 0) {
-                is_valid = false;
-                return;
-            }
-        } else {
-            ++level;
-        }
-    }
-
-    is_valid = true;
-    is_root = level == 0;
-}
-
-PathParser::HostStatus PathParser::GetHostStatus(const std::string& mount_point) const {
-    auto path = mount_point;
-    if (!FileUtil::IsDirectory(path))
-        return InvalidMountPoint;
-    if (path_sequence.empty()) {
-        return DirectoryFound;
-    }
-
-    for (auto iter = path_sequence.begin(); iter != path_sequence.end() - 1; iter++) {
-        if (path.back() != '/')
-            path += '/';
-        path += *iter;
-
-        if (!FileUtil::Exists(path))
-            return PathNotFound;
-        if (FileUtil::IsDirectory(path))
-            continue;
-        return FileInPath;
-    }
-
-    path += "/" + path_sequence.back();
-    if (!FileUtil::Exists(path))
-        return NotFound;
-    if (FileUtil::IsDirectory(path))
-        return DirectoryFound;
-    return FileFound;
-}
-
-std::string PathParser::BuildHostPath(const std::string& mount_point) const {
-    std::string path = mount_point;
-    for (auto& node : path_sequence) {
-        if (path.back() != '/')
-            path += '/';
-        path += node;
-    }
-    return path;
-}
-
-} // namespace FileSys

src/core/file_sys/path_parser.h

@@ -1,61 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include "core/file_sys/filesystem.h"
-
-namespace FileSys {
-
-/**
- * A helper class parsing and verifying a string-type Path.
- * Every archives with a sub file system should use this class to parse the path argument and check
- * the status of the file / directory in question on the host file system.
- */
-class PathParser {
-public:
-    explicit PathParser(const Path& path);
-
-    /**
-     * Checks if the Path is valid.
-     * This function should be called once a PathParser is constructed.
-     * A Path is valid if:
-     *  - it is a string path (with type LowPathType::Char or LowPathType::Wchar),
-     *  - it starts with "/" (this seems a hard requirement in real 3DS),
-     *  - it doesn't contain invalid characters, and
-     *  - it doesn't go out of the root directory using "..".
-     */
-    bool IsValid() const {
-        return is_valid;
-    }
-
-    /// Checks if the Path represents the root directory.
-    bool IsRootDirectory() const {
-        return is_root;
-    }
-
-    enum HostStatus {
-        InvalidMountPoint,
-        PathNotFound,   // "/a/b/c" when "a" doesn't exist
-        FileInPath,     // "/a/b/c" when "a" is a file
-        FileFound,      // "/a/b/c" when "c" is a file
-        DirectoryFound, // "/a/b/c" when "c" is a directory
-        NotFound        // "/a/b/c" when "a/b/" exists but "c" doesn't exist
-    };
-
-    /// Checks the status of the specified file / directory by the Path on the host file system.
-    HostStatus GetHostStatus(const std::string& mount_point) const;
-
-    /// Builds a full path on the host file system.
-    std::string BuildHostPath(const std::string& mount_point) const;
-
-private:
-    std::vector<std::string> path_sequence;
-    bool is_valid{};
-    bool is_root{};
-};
-
-} // namespace FileSys

src/core/file_sys/program_metadata.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/program_metadata.h"
@@ -10,40 +9,29 @@
 
 namespace FileSys {
 
-Loader::ResultStatus ProgramMetadata::Load(const std::string& file_path) {
-    FileUtil::IOFile file(file_path, "rb");
-    if (!file.IsOpen())
-        return Loader::ResultStatus::Error;
-
-    std::vector<u8> file_data(file.GetSize());
-
-    if (!file.ReadBytes(file_data.data(), file_data.size()))
-        return Loader::ResultStatus::Error;
-
-    Loader::ResultStatus result = Load(file_data);
-    if (result != Loader::ResultStatus::Success)
-        LOG_ERROR(Service_FS, "Failed to load NPDM from file %s!", file_path.c_str());
-
-    return result;
-}
-
-Loader::ResultStatus ProgramMetadata::Load(const std::vector<u8> file_data, size_t offset) {
-    size_t total_size = static_cast<size_t>(file_data.size() - offset);
+Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
+    size_t total_size = static_cast<size_t>(file->GetSize());
     if (total_size < sizeof(Header))
         return Loader::ResultStatus::Error;
 
-    size_t header_offset = offset;
-    memcpy(&npdm_header, &file_data[offset], sizeof(Header));
+    // TODO(DarkLordZach): Use ReadObject when Header/AcidHeader becomes trivially copyable.
+    std::vector<u8> npdm_header_data = file->ReadBytes(sizeof(Header));
+    if (sizeof(Header) != npdm_header_data.size())
+        return Loader::ResultStatus::Error;
+    std::memcpy(&npdm_header, npdm_header_data.data(), sizeof(Header));
 
-    size_t aci_offset = header_offset + npdm_header.aci_offset;
-    size_t acid_offset = header_offset + npdm_header.acid_offset;
-    memcpy(&aci_header, &file_data[aci_offset], sizeof(AciHeader));
-    memcpy(&acid_header, &file_data[acid_offset], sizeof(AcidHeader));
+    std::vector<u8> acid_header_data = file->ReadBytes(sizeof(AcidHeader), npdm_header.acid_offset);
+    if (sizeof(AcidHeader) != acid_header_data.size())
+        return Loader::ResultStatus::Error;
+    std::memcpy(&acid_header, acid_header_data.data(), sizeof(AcidHeader));
 
-    size_t fac_offset = acid_offset + acid_header.fac_offset;
-    size_t fah_offset = aci_offset + aci_header.fah_offset;
-    memcpy(&acid_file_access, &file_data[fac_offset], sizeof(FileAccessControl));
-    memcpy(&aci_file_access, &file_data[fah_offset], sizeof(FileAccessHeader));
+    if (sizeof(AciHeader) != file->ReadObject(&aci_header, npdm_header.aci_offset))
+        return Loader::ResultStatus::Error;
+
+    if (sizeof(FileAccessControl) != file->ReadObject(&acid_file_access, acid_header.fac_offset))
+        return Loader::ResultStatus::Error;
+    if (sizeof(FileAccessHeader) != file->ReadObject(&aci_file_access, aci_header.fah_offset))
+        return Loader::ResultStatus::Error;
 
     return Loader::ResultStatus::Success;
 }
@@ -77,13 +65,13 @@ u64 ProgramMetadata::GetFilesystemPermissions() const {
 }
 
 void ProgramMetadata::Print() const {
-    LOG_DEBUG(Service_FS, "Magic:                  %.4s", npdm_header.magic.data());
-    LOG_DEBUG(Service_FS, "Main thread priority:   0x%02x", npdm_header.main_thread_priority);
-    LOG_DEBUG(Service_FS, "Main thread core:       %u", npdm_header.main_thread_cpu);
-    LOG_DEBUG(Service_FS, "Main thread stack size: 0x%x bytes", npdm_header.main_stack_size);
-    LOG_DEBUG(Service_FS, "Process category:       %u", npdm_header.process_category);
-    LOG_DEBUG(Service_FS, "Flags:                  %02x", npdm_header.flags);
-    LOG_DEBUG(Service_FS, " > 64-bit instructions: %s",
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", npdm_header.magic.data());
+    LOG_DEBUG(Service_FS, "Main thread priority:   0x{:02X}", npdm_header.main_thread_priority);
+    LOG_DEBUG(Service_FS, "Main thread core:       {}", npdm_header.main_thread_cpu);
+    LOG_DEBUG(Service_FS, "Main thread stack size: 0x{:X} bytes", npdm_header.main_stack_size);
+    LOG_DEBUG(Service_FS, "Process category:       {}", npdm_header.process_category);
+    LOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", npdm_header.flags);
+    LOG_DEBUG(Service_FS, " > 64-bit instructions: {}",
               npdm_header.has_64_bit_instructions ? "YES" : "NO");
 
     auto address_space = "Unknown";
@@ -96,19 +84,19 @@ void ProgramMetadata::Print() const {
         break;
     }
 
-    LOG_DEBUG(Service_FS, " > Address space:       %s\n", address_space);
+    LOG_DEBUG(Service_FS, " > Address space:       {}\n", address_space);
 
     // Begin ACID printing (potential perms, signed)
-    LOG_DEBUG(Service_FS, "Magic:                  %.4s", acid_header.magic.data());
-    LOG_DEBUG(Service_FS, "Flags:                  %02x", acid_header.flags);
-    LOG_DEBUG(Service_FS, " > Is Retail:           %s", acid_header.is_retail ? "YES" : "NO");
-    LOG_DEBUG(Service_FS, "Title ID Min:           %016" PRIX64, acid_header.title_id_min);
-    LOG_DEBUG(Service_FS, "Title ID Max:           %016" PRIX64, acid_header.title_id_max);
-    LOG_DEBUG(Service_FS, "Filesystem Access:      %016" PRIX64 "\n", acid_file_access.permissions);
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", acid_header.magic.data());
+    LOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", acid_header.flags);
+    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);
 
     // Begin ACI0 printing (actual perms, unsigned)
-    LOG_DEBUG(Service_FS, "Magic:                  %.4s", aci_header.magic.data());
-    LOG_DEBUG(Service_FS, "Title ID:               %016" PRIX64, aci_header.title_id);
-    LOG_DEBUG(Service_FS, "Filesystem Access:      %016" PRIX64 "\n", aci_file_access.permissions);
+    LOG_DEBUG(Service_FS, "Magic:                  {:.4}", aci_header.magic.data());
+    LOG_DEBUG(Service_FS, "Title ID:               0x{:016X}", aci_header.title_id);
+    LOG_DEBUG(Service_FS, "Filesystem Access:      0x{:016X}\n", aci_file_access.permissions);
 }
 } // namespace FileSys

src/core/file_sys/program_metadata.h

@@ -10,6 +10,7 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "partition_filesystem.h"
 
 namespace Loader {
 enum class ResultStatus;
@@ -37,8 +38,7 @@ enum class ProgramFilePermission : u64 {
  */
 class ProgramMetadata {
 public:
-    Loader::ResultStatus Load(const std::string& file_path);
-    Loader::ResultStatus Load(const std::vector<u8> file_data, size_t offset = 0);
+    Loader::ResultStatus Load(VirtualFile file);
 
     bool Is64BitProgram() const;
     ProgramAddressSpaceType GetAddressSpaceType() const;
@@ -51,6 +51,7 @@ public:
     void Print() const;
 
 private:
+    // TODO(DarkLordZach): BitField is not trivially copyable.
     struct Header {
         std::array<char, 4> magic;
         std::array<u8, 8> reserved;
@@ -77,6 +78,7 @@ private:
 
     static_assert(sizeof(Header) == 0x80, "NPDM header structure size is wrong");
 
+    // TODO(DarkLordZach): BitField is not trivially copyable.
     struct AcidHeader {
         std::array<u8, 0x100> signature;
         std::array<u8, 0x100> nca_modulus;

src/core/file_sys/romfs_factory.cpp

@@ -7,32 +7,19 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/file_sys/romfs_factory.h"
-#include "core/file_sys/romfs_filesystem.h"
 
 namespace FileSys {
 
-RomFS_Factory::RomFS_Factory(Loader::AppLoader& app_loader) {
+RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     // Load the RomFS from the app
-    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(romfs_file, data_offset, data_size)) {
+    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(file)) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
     }
 }
 
-ResultVal<std::unique_ptr<FileSystemBackend>> RomFS_Factory::Open(const Path& path) {
-    auto archive = std::make_unique<RomFS_FileSystem>(romfs_file, data_offset, data_size);
-    return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
-}
-
-ResultCode RomFS_Factory::Format(const Path& path) {
-    LOG_ERROR(Service_FS, "Unimplemented Format archive %s", GetName().c_str());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
-ResultVal<ArchiveFormatInfo> RomFS_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive %s", GetName().c_str());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id) {
+    // TODO(DarkLordZach): Use title id.
+    return MakeResult<VirtualFile>(file);
 }
 
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -5,31 +5,21 @@
 #pragma once
 
 #include <memory>
-#include <string>
-#include <vector>
 #include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
 #include "core/hle/result.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
 
 /// File system interface to the RomFS archive
-class RomFS_Factory final : public FileSystemFactory {
+class RomFSFactory {
 public:
-    explicit RomFS_Factory(Loader::AppLoader& app_loader);
+    explicit RomFSFactory(Loader::AppLoader& app_loader);
 
-    std::string GetName() const override {
-        return "ArchiveFactory_RomFS";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
+    ResultVal<VirtualFile> Open(u64 title_id);
 
 private:
-    std::shared_ptr<FileUtil::IOFile> romfs_file;
-    u64 data_offset;
-    u64 data_size;
+    VirtualFile file;
 };
 
 } // namespace FileSys

src/core/file_sys/romfs_filesystem.cpp

@@ -1,113 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <memory>
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/file_sys/romfs_filesystem.h"
-
-namespace FileSys {
-
-std::string RomFS_FileSystem::GetName() const {
-    return "RomFS";
-}
-
-ResultVal<std::unique_ptr<StorageBackend>> RomFS_FileSystem::OpenFile(const std::string& path,
-                                                                      Mode mode) const {
-    return MakeResult<std::unique_ptr<StorageBackend>>(
-        std::make_unique<RomFS_Storage>(romfs_file, data_offset, data_size));
-}
-
-ResultCode RomFS_FileSystem::DeleteFile(const std::string& path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to delete a file from an ROMFS archive (%s).",
-                 GetName().c_str());
-    // TODO(bunnei): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode RomFS_FileSystem::RenameFile(const Path& src_path, const Path& dest_path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an ROMFS archive (%s).",
-                 GetName().c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode RomFS_FileSystem::DeleteDirectory(const Path& path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an ROMFS archive (%s).",
-                 GetName().c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode RomFS_FileSystem::DeleteDirectoryRecursively(const Path& path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to delete a directory from an ROMFS archive (%s).",
-                 GetName().c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode RomFS_FileSystem::CreateFile(const std::string& path, u64 size) const {
-    LOG_CRITICAL(Service_FS, "Attempted to create a file in an ROMFS archive (%s).",
-                 GetName().c_str());
-    // TODO(bunnei): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode RomFS_FileSystem::CreateDirectory(const std::string& path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to create a directory in an ROMFS archive (%s).",
-                 GetName().c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode RomFS_FileSystem::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    LOG_CRITICAL(Service_FS, "Attempted to rename a file within an ROMFS archive (%s).",
-                 GetName().c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultVal<std::unique_ptr<DirectoryBackend>> RomFS_FileSystem::OpenDirectory(
-    const std::string& path) const {
-    LOG_WARNING(Service_FS, "Opening Directory in a ROMFS archive");
-    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::make_unique<ROMFSDirectory>());
-}
-
-u64 RomFS_FileSystem::GetFreeSpaceSize() const {
-    LOG_WARNING(Service_FS, "Attempted to get the free space in an ROMFS archive");
-    return 0;
-}
-
-ResultVal<FileSys::EntryType> RomFS_FileSystem::GetEntryType(const std::string& path) const {
-    LOG_CRITICAL(Service_FS, "Called within an ROMFS archive (path %s).", path.c_str());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultVal<size_t> RomFS_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
-    LOG_TRACE(Service_FS, "called offset=%llu, length=%zu", offset, length);
-    romfs_file->Seek(data_offset + offset, SEEK_SET);
-    size_t read_length = (size_t)std::min((u64)length, data_size - offset);
-
-    return MakeResult<size_t>(romfs_file->ReadBytes(buffer, read_length));
-}
-
-ResultVal<size_t> RomFS_Storage::Write(const u64 offset, const size_t length, const bool flush,
-                                       const u8* buffer) const {
-    LOG_ERROR(Service_FS, "Attempted to write to ROMFS file");
-    // TODO(Subv): Find error code
-    return MakeResult<size_t>(0);
-}
-
-u64 RomFS_Storage::GetSize() const {
-    return data_size;
-}
-
-bool RomFS_Storage::SetSize(const u64 size) const {
-    LOG_ERROR(Service_FS, "Attempted to set the size of an ROMFS file");
-    return false;
-}
-
-} // namespace FileSys

src/core/file_sys/romfs_filesystem.h

@@ -1,85 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <memory>
-#include <string>
-#include <vector>
-#include "common/common_types.h"
-#include "common/file_util.h"
-#include "core/file_sys/directory.h"
-#include "core/file_sys/filesystem.h"
-#include "core/file_sys/storage.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-/**
- * Helper which implements an interface to deal with Switch .istorage ROMFS images used in some
- * archives This should be subclassed by concrete archive types, which will provide the input data
- * (load the raw ROMFS archive) and override any required methods
- */
-class RomFS_FileSystem : public FileSystemBackend {
-public:
-    RomFS_FileSystem(std::shared_ptr<FileUtil::IOFile> file, u64 offset, u64 size)
-        : romfs_file(file), data_offset(offset), data_size(size) {}
-
-    std::string GetName() const override;
-
-    ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                        Mode mode) const override;
-    ResultCode DeleteFile(const std::string& path) const override;
-    ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
-    ResultCode DeleteDirectory(const Path& path) const override;
-    ResultCode DeleteDirectoryRecursively(const Path& path) const override;
-    ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const std::string& path) const override;
-    ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const override;
-    u64 GetFreeSpaceSize() const override;
-    ResultVal<EntryType> GetEntryType(const std::string& path) const override;
-
-protected:
-    std::shared_ptr<FileUtil::IOFile> romfs_file;
-    u64 data_offset;
-    u64 data_size;
-};
-
-class RomFS_Storage : public StorageBackend {
-public:
-    RomFS_Storage(std::shared_ptr<FileUtil::IOFile> file, u64 offset, u64 size)
-        : romfs_file(file), data_offset(offset), data_size(size) {}
-
-    ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const override;
-    ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const override;
-    u64 GetSize() const override;
-    bool SetSize(u64 size) const override;
-    bool Close() const override {
-        return false;
-    }
-    void Flush() const override {}
-
-private:
-    std::shared_ptr<FileUtil::IOFile> romfs_file;
-    u64 data_offset;
-    u64 data_size;
-};
-
-class ROMFSDirectory : public DirectoryBackend {
-public:
-    u64 Read(const u64 count, Entry* entries) override {
-        return 0;
-    }
-    u64 GetEntryCount() const override {
-        return 0;
-    }
-    bool Close() const override {
-        return false;
-    }
-};
-
-} // namespace FileSys

src/core/file_sys/savedata_factory.cpp

@@ -2,56 +2,105 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
 #include <memory>
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/core.h"
-#include "core/file_sys/disk_filesystem.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/kernel/process.h"
 
 namespace FileSys {
 
-SaveData_Factory::SaveData_Factory(std::string nand_directory)
-    : nand_directory(std::move(nand_directory)) {}
+std::string SaveDataDescriptor::DebugInfo() {
+    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}]",
+                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id);
+}
+
+SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {}
+
+ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescriptor meta) {
+    if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
+        if (meta.zero_1 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x28 is non-zero ({:016X}).",
+                        meta.zero_1);
+        }
+        if (meta.zero_2 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x30 is non-zero ({:016X}).",
+                        meta.zero_2);
+        }
+        if (meta.zero_3 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x38 is non-zero ({:016X}).",
+                        meta.zero_3);
+        }
+    }
+
+    if (meta.type == SaveDataType::SystemSaveData && meta.title_id != 0) {
+        LOG_WARNING(Service_FS,
+                    "Possibly incorrect SaveDataDescriptor, type is SystemSaveData but title_id is "
+                    "non-zero ({:016X}).",
+                    meta.title_id);
+    }
+
+    std::string save_directory =
+        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+
+    // TODO(DarkLordZach): Try to not create when opening, there are dedicated create save methods.
+    // But, user_ids don't match so this works for now.
+
+    auto out = dir->GetDirectoryRelative(save_directory);
+
+    if (out == nullptr) {
+        // TODO(bunnei): This is a work-around to always create a save data directory if it does not
+        // already exist. This is a hack, as we do not understand yet how this works on hardware.
+        // Without a save data directory, many games will assert on boot. This should not have any
+        // bad side-effects.
+        out = dir->CreateDirectoryRelative(save_directory);
+    }
 
-ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path& path) {
-    std::string save_directory = GetFullPath();
     // Return an error if the save data doesn't actually exist.
-    if (!FileUtil::IsDirectory(save_directory)) {
+    if (out == nullptr) {
         // TODO(Subv): Find out correct error code.
         return ResultCode(-1);
     }
 
-    auto archive = std::make_unique<Disk_FileSystem>(save_directory);
-    return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
+    return MakeResult<VirtualDir>(std::move(out));
 }
 
-ResultCode SaveData_Factory::Format(const Path& path) {
-    LOG_WARNING(Service_FS, "Format archive %s", GetName().c_str());
-    // Create the save data directory.
-    if (!FileUtil::CreateFullPath(GetFullPath())) {
-        // TODO(Subv): Find the correct error code.
-        return ResultCode(-1);
+std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
+                                         u128 user_id, u64 save_id) const {
+    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
+    // be interpreted as the title id of the current process.
+    if (type == SaveDataType::SaveData && title_id == 0)
+        title_id = Core::CurrentProcess()->program_id;
+
+    std::string out;
+
+    switch (space) {
+    case SaveDataSpaceId::NandSystem:
+        out = "/system/save/";
+        break;
+    case SaveDataSpaceId::NandUser:
+        out = "/user/save/";
+        break;
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
     }
 
-    return RESULT_SUCCESS;
-}
-
-ResultVal<ArchiveFormatInfo> SaveData_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive %s", GetName().c_str());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
-std::string SaveData_Factory::GetFullPath() const {
-    u64 title_id = Core::CurrentProcess()->program_id;
-    // TODO(Subv): Somehow obtain this value.
-    u32 user = 0;
-    return Common::StringFromFormat("%ssave/%016" PRIX64 "/%08X/", nand_directory.c_str(), title_id,
-                                    user);
+    switch (type) {
+    case SaveDataType::SystemSaveData:
+        return fmt::format("{}{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);
+    case SaveDataType::SaveData:
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+                           title_id);
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));
+    }
 }
 
 } // namespace FileSys

src/core/file_sys/savedata_factory.h

@@ -7,27 +7,52 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
 
-/// File system interface to the SaveData archive
-class SaveData_Factory final : public FileSystemFactory {
-public:
-    explicit SaveData_Factory(std::string nand_directory);
+enum class SaveDataSpaceId : u8 {
+    NandSystem = 0,
+    NandUser = 1,
+    SdCard = 2,
+    TemporaryStorage = 3,
+};
 
-    std::string GetName() const override {
-        return "SaveData_Factory";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
+enum class SaveDataType : u8 {
+    SystemSaveData = 0,
+    SaveData = 1,
+    BcatDeliveryCacheStorage = 2,
+    DeviceSaveData = 3,
+    TemporaryStorage = 4,
+    CacheStorage = 5,
+};
+
+struct SaveDataDescriptor {
+    u64_le title_id;
+    u128 user_id;
+    u64_le save_id;
+    SaveDataType type;
+    INSERT_PADDING_BYTES(7);
+    u64_le zero_1;
+    u64_le zero_2;
+    u64_le zero_3;
+
+    std::string DebugInfo();
+};
+static_assert(sizeof(SaveDataDescriptor) == 0x40, "SaveDataDescriptor has incorrect size.");
+
+/// File system interface to the SaveData archive
+class SaveDataFactory {
+public:
+    explicit SaveDataFactory(VirtualDir dir);
+
+    ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
 
 private:
-    std::string nand_directory;
+    VirtualDir dir;
 
-    std::string GetFullPath() const;
+    std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id,
+                            u64 save_id) const;
 };
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.cpp

@@ -2,39 +2,16 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cinttypes>
 #include <memory>
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/core.h"
-#include "core/file_sys/disk_filesystem.h"
 #include "core/file_sys/sdmc_factory.h"
 
 namespace FileSys {
 
-SDMC_Factory::SDMC_Factory(std::string sd_directory) : sd_directory(std::move(sd_directory)) {}
+SDMCFactory::SDMCFactory(VirtualDir dir) : dir(std::move(dir)) {}
 
-ResultVal<std::unique_ptr<FileSystemBackend>> SDMC_Factory::Open(const Path& path) {
-    // Create the SD Card directory if it doesn't already exist.
-    if (!FileUtil::IsDirectory(sd_directory)) {
-        FileUtil::CreateFullPath(sd_directory);
-    }
-
-    auto archive = std::make_unique<Disk_FileSystem>(sd_directory);
-    return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
-}
-
-ResultCode SDMC_Factory::Format(const Path& path) {
-    LOG_ERROR(Service_FS, "Unimplemented Format archive %s", GetName().c_str());
-    // TODO(Subv): Find the right error code for this
-    return ResultCode(-1);
-}
-
-ResultVal<ArchiveFormatInfo> SDMC_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive %s", GetName().c_str());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
+ResultVal<VirtualDir> SDMCFactory::Open() {
+    return MakeResult<VirtualDir>(dir);
 }
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -4,28 +4,19 @@
 
 #pragma once
 
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
 
 /// File system interface to the SDCard archive
-class SDMC_Factory final : public FileSystemFactory {
+class SDMCFactory {
 public:
-    explicit SDMC_Factory(std::string sd_directory);
+    explicit SDMCFactory(VirtualDir dir);
 
-    std::string GetName() const override {
-        return "SDMC_Factory";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
+    ResultVal<VirtualDir> Open();
 
 private:
-    std::string sd_directory;
+    VirtualDir dir;
 };
 
 } // namespace FileSys

src/core/file_sys/storage.h

@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include "common/common_types.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class StorageBackend : NonCopyable {
-public:
-    StorageBackend() {}
-    virtual ~StorageBackend() {}
-
-    /**
-     * Read data from the file
-     * @param offset Offset in bytes to start reading data from
-     * @param length Length in bytes of data to read from file
-     * @param buffer Buffer to read data into
-     * @return Number of bytes read, or error code
-     */
-    virtual ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const = 0;
-
-    /**
-     * Write data to the file
-     * @param offset Offset in bytes to start writing data to
-     * @param length Length in bytes of data to write to file
-     * @param flush The flush parameters (0 == do not flush)
-     * @param buffer Buffer to read data from
-     * @return Number of bytes written, or error code
-     */
-    virtual ResultVal<size_t> Write(u64 offset, size_t length, bool flush,
-                                    const u8* buffer) const = 0;
-
-    /**
-     * Flushes the file
-     */
-    virtual void Flush() const = 0;
-
-    /**
-     * Set the size of the file in bytes
-     * @param size New size of the file
-     * @return true if successful
-     */
-    virtual bool SetSize(u64 size) const = 0;
-
-    /**
-     * Get the size of the file in bytes
-     * @return Size of the file in bytes
-     */
-    virtual u64 GetSize() const = 0;
-
-    /**
-     * Close the file
-     * @return true if the file closed correctly
-     */
-    virtual bool Close() const = 0;
-};
-
-} // namespace FileSys

src/core/file_sys/vfs.cpp

@@ -0,0 +1,238 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <numeric>
+#include "common/file_util.h"
+#include "common/logging/backend.h"
+#include "core/file_sys/vfs.h"
+
+namespace FileSys {
+
+VfsFile::~VfsFile() = default;
+
+std::string VfsFile::GetExtension() const {
+    return FileUtil::GetExtensionFromFilename(GetName());
+}
+
+VfsDirectory::~VfsDirectory() = default;
+
+boost::optional<u8> VfsFile::ReadByte(size_t offset) const {
+    u8 out{};
+    size_t size = Read(&out, 1, offset);
+    if (size == 1)
+        return out;
+
+    return boost::none;
+}
+
+std::vector<u8> VfsFile::ReadBytes(size_t size, size_t offset) const {
+    std::vector<u8> out(size);
+    size_t read_size = Read(out.data(), size, offset);
+    out.resize(read_size);
+    return out;
+}
+
+std::vector<u8> VfsFile::ReadAllBytes() const {
+    return ReadBytes(GetSize());
+}
+
+bool VfsFile::WriteByte(u8 data, size_t offset) {
+    return Write(&data, 1, offset) == 1;
+}
+
+size_t VfsFile::WriteBytes(std::vector<u8> data, size_t offset) {
+    return Write(data.data(), data.size(), offset);
+}
+
+std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(const std::string& path) const {
+    auto vec = FileUtil::SplitPathComponents(path);
+    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
+              vec.end());
+    if (vec.empty())
+        return nullptr;
+    if (vec.size() == 1)
+        return GetFile(vec[0]);
+    auto dir = GetSubdirectory(vec[0]);
+    for (size_t component = 1; component < vec.size() - 1; ++component) {
+        if (dir == nullptr)
+            return nullptr;
+        dir = dir->GetSubdirectory(vec[component]);
+    }
+    if (dir == nullptr)
+        return nullptr;
+    return dir->GetFile(vec.back());
+}
+
+std::shared_ptr<VfsFile> VfsDirectory::GetFileAbsolute(const std::string& path) const {
+    if (IsRoot())
+        return GetFileRelative(path);
+
+    return GetParentDirectory()->GetFileAbsolute(path);
+}
+
+std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(const std::string& path) const {
+    auto vec = FileUtil::SplitPathComponents(path);
+    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
+              vec.end());
+    if (vec.empty())
+        // TODO(DarkLordZach): Return this directory if path is '/' or similar. Can't currently
+        // because of const-ness
+        return nullptr;
+    auto dir = GetSubdirectory(vec[0]);
+    for (size_t component = 1; component < vec.size(); ++component) {
+        if (dir == nullptr)
+            return nullptr;
+        dir = dir->GetSubdirectory(vec[component]);
+    }
+    return dir;
+}
+
+std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryAbsolute(const std::string& path) const {
+    if (IsRoot())
+        return GetDirectoryRelative(path);
+
+    return GetParentDirectory()->GetDirectoryAbsolute(path);
+}
+
+std::shared_ptr<VfsFile> VfsDirectory::GetFile(const std::string& name) const {
+    const auto& files = GetFiles();
+    const auto iter = std::find_if(files.begin(), files.end(),
+                                   [&name](const auto& file1) { return name == file1->GetName(); });
+    return iter == files.end() ? nullptr : *iter;
+}
+
+std::shared_ptr<VfsDirectory> VfsDirectory::GetSubdirectory(const std::string& name) const {
+    const auto& subs = GetSubdirectories();
+    const auto iter = std::find_if(subs.begin(), subs.end(),
+                                   [&name](const auto& file1) { return name == file1->GetName(); });
+    return iter == subs.end() ? nullptr : *iter;
+}
+
+bool VfsDirectory::IsRoot() const {
+    return GetParentDirectory() == nullptr;
+}
+
+size_t VfsDirectory::GetSize() const {
+    const auto& files = GetFiles();
+    const auto file_total =
+        std::accumulate(files.begin(), files.end(), 0ull,
+                        [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); });
+
+    const auto& sub_dir = GetSubdirectories();
+    const auto subdir_total =
+        std::accumulate(sub_dir.begin(), sub_dir.end(), 0ull,
+                        [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); });
+
+    return file_total + subdir_total;
+}
+
+std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(const std::string& path) {
+    auto vec = FileUtil::SplitPathComponents(path);
+    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
+              vec.end());
+    if (vec.empty())
+        return nullptr;
+    if (vec.size() == 1)
+        return CreateFile(vec[0]);
+    auto dir = GetSubdirectory(vec[0]);
+    if (dir == nullptr) {
+        dir = CreateSubdirectory(vec[0]);
+        if (dir == nullptr)
+            return nullptr;
+    }
+
+    return dir->CreateFileRelative(FileUtil::GetPathWithoutTop(path));
+}
+
+std::shared_ptr<VfsFile> VfsDirectory::CreateFileAbsolute(const std::string& path) {
+    if (IsRoot())
+        return CreateFileRelative(path);
+    return GetParentDirectory()->CreateFileAbsolute(path);
+}
+
+std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(const std::string& path) {
+    auto vec = FileUtil::SplitPathComponents(path);
+    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
+              vec.end());
+    if (vec.empty())
+        return nullptr;
+    if (vec.size() == 1)
+        return CreateSubdirectory(vec[0]);
+    auto dir = GetSubdirectory(vec[0]);
+    if (dir == nullptr) {
+        dir = CreateSubdirectory(vec[0]);
+        if (dir == nullptr)
+            return nullptr;
+    }
+    return dir->CreateDirectoryRelative(FileUtil::GetPathWithoutTop(path));
+}
+
+std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryAbsolute(const std::string& path) {
+    if (IsRoot())
+        return CreateDirectoryRelative(path);
+    return GetParentDirectory()->CreateDirectoryAbsolute(path);
+}
+
+bool VfsDirectory::DeleteSubdirectoryRecursive(const std::string& name) {
+    auto dir = GetSubdirectory(name);
+    if (dir == nullptr)
+        return false;
+
+    bool success = true;
+    for (const auto& file : dir->GetFiles()) {
+        if (!DeleteFile(file->GetName()))
+            success = false;
+    }
+
+    for (const auto& sdir : dir->GetSubdirectories()) {
+        if (!dir->DeleteSubdirectoryRecursive(sdir->GetName()))
+            success = false;
+    }
+
+    return success;
+}
+
+bool VfsDirectory::Copy(const std::string& src, const std::string& dest) {
+    const auto f1 = GetFile(src);
+    auto f2 = CreateFile(dest);
+    if (f1 == nullptr || f2 == nullptr)
+        return false;
+
+    if (!f2->Resize(f1->GetSize())) {
+        DeleteFile(dest);
+        return false;
+    }
+
+    return f2->WriteBytes(f1->ReadAllBytes()) == f1->GetSize();
+}
+
+bool ReadOnlyVfsDirectory::IsWritable() const {
+    return false;
+}
+
+bool ReadOnlyVfsDirectory::IsReadable() const {
+    return true;
+}
+
+std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateSubdirectory(const std::string& name) {
+    return nullptr;
+}
+
+std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFile(const std::string& name) {
+    return nullptr;
+}
+
+bool ReadOnlyVfsDirectory::DeleteSubdirectory(const std::string& name) {
+    return false;
+}
+
+bool ReadOnlyVfsDirectory::DeleteFile(const std::string& name) {
+    return false;
+}
+
+bool ReadOnlyVfsDirectory::Rename(const std::string& name) {
+    return false;
+}
+} // namespace FileSys

src/core/file_sys/vfs.h

@@ -0,0 +1,237 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <vector>
+#include "boost/optional.hpp"
+#include "common/common_types.h"
+#include "common/file_util.h"
+
+namespace FileSys {
+struct VfsFile;
+struct VfsDirectory;
+
+// Convenience typedefs to use VfsDirectory and VfsFile
+using VirtualDir = std::shared_ptr<FileSys::VfsDirectory>;
+using VirtualFile = std::shared_ptr<FileSys::VfsFile>;
+
+// A class representing a file in an abstract filesystem.
+struct VfsFile : NonCopyable {
+    virtual ~VfsFile();
+
+    // Retrieves the file name.
+    virtual std::string GetName() const = 0;
+    // Retrieves the extension of the file name.
+    virtual std::string GetExtension() const;
+    // Retrieves the size of the file.
+    virtual size_t GetSize() const = 0;
+    // Resizes the file to new_size. Returns whether or not the operation was successful.
+    virtual bool Resize(size_t new_size) = 0;
+    // Gets a pointer to the directory containing this file, returning nullptr if there is none.
+    virtual std::shared_ptr<VfsDirectory> GetContainingDirectory() const = 0;
+
+    // Returns whether or not the file can be written to.
+    virtual bool IsWritable() const = 0;
+    // Returns whether or not the file can be read from.
+    virtual bool IsReadable() const = 0;
+
+    // The primary method of reading from the file. Reads length bytes into data starting at offset
+    // into file. Returns number of bytes successfully read.
+    virtual size_t Read(u8* data, size_t length, size_t offset = 0) const = 0;
+    // The primary method of writing to the file. Writes length bytes from data starting at offset
+    // into file. Returns number of bytes successfully written.
+    virtual size_t Write(const u8* data, size_t length, size_t offset = 0) = 0;
+
+    // Reads exactly one byte at the offset provided, returning boost::none on error.
+    virtual boost::optional<u8> ReadByte(size_t offset = 0) const;
+    // Reads size bytes starting at offset in file into a vector.
+    virtual std::vector<u8> ReadBytes(size_t size, size_t offset = 0) const;
+    // Reads all the bytes from the file into a vector. Equivalent to 'file->Read(file->GetSize(),
+    // 0)'
+    virtual std::vector<u8> ReadAllBytes() const;
+
+    // Reads an array of type T, size number_elements starting at offset.
+    // Returns the number of bytes (sizeof(T)*number_elements) read successfully.
+    template <typename T>
+    size_t ReadArray(T* data, size_t number_elements, size_t offset = 0) const {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+
+        return Read(reinterpret_cast<u8*>(data), number_elements * sizeof(T), offset);
+    }
+
+    // Reads size bytes into the memory starting at data starting at offset into the file.
+    // Returns the number of bytes read successfully.
+    template <typename T>
+    size_t ReadBytes(T* data, size_t size, size_t offset = 0) const {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+        return Read(reinterpret_cast<u8*>(data), size, offset);
+    }
+
+    // Reads one object of type T starting at offset in file.
+    // Returns the number of bytes read successfully (sizeof(T)).
+    template <typename T>
+    size_t ReadObject(T* data, size_t offset = 0) const {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+        return Read(reinterpret_cast<u8*>(data), sizeof(T), offset);
+    }
+
+    // Writes exactly one byte to offset in file and retuns whether or not the byte was written
+    // successfully.
+    virtual bool WriteByte(u8 data, size_t offset = 0);
+    // Writes a vector of bytes to offset in file and returns the number of bytes successfully
+    // written.
+    virtual size_t WriteBytes(std::vector<u8> data, size_t offset = 0);
+
+    // Writes an array of type T, size number_elements to offset in file.
+    // Returns the number of bytes (sizeof(T)*number_elements) written successfully.
+    template <typename T>
+    size_t WriteArray(T* data, size_t number_elements, size_t offset = 0) {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+
+        return Write(data, number_elements * sizeof(T), offset);
+    }
+
+    // Writes size bytes starting at memory location data to offset in file.
+    // Returns the number of bytes written successfully.
+    template <typename T>
+    size_t WriteBytes(T* data, size_t size, size_t offset = 0) {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+        return Write(reinterpret_cast<u8*>(data), size, offset);
+    }
+
+    // Writes one object of type T to offset in file.
+    // Returns the number of bytes written successfully (sizeof(T)).
+    template <typename T>
+    size_t WriteObject(const T& data, size_t offset = 0) {
+        static_assert(std::is_trivially_copyable<T>::value,
+                      "Data type must be trivially copyable.");
+        return Write(&data, sizeof(T), offset);
+    }
+
+    // Renames the file to name. Returns whether or not the operation was successsful.
+    virtual bool Rename(const std::string& name) = 0;
+};
+
+// A class representing a directory in an abstract filesystem.
+struct VfsDirectory : NonCopyable {
+    virtual ~VfsDirectory();
+
+    // Retrives the file located at path as if the current directory was root. Returns nullptr if
+    // not found.
+    virtual std::shared_ptr<VfsFile> GetFileRelative(const std::string& path) const;
+    // Calls GetFileRelative(path) on the root of the current directory.
+    virtual std::shared_ptr<VfsFile> GetFileAbsolute(const std::string& path) const;
+
+    // Retrives the directory located at path as if the current directory was root. Returns nullptr
+    // if not found.
+    virtual std::shared_ptr<VfsDirectory> GetDirectoryRelative(const std::string& path) const;
+    // Calls GetDirectoryRelative(path) on the root of the current directory.
+    virtual std::shared_ptr<VfsDirectory> GetDirectoryAbsolute(const std::string& path) const;
+
+    // Returns a vector containing all of the files in this directory.
+    virtual std::vector<std::shared_ptr<VfsFile>> GetFiles() const = 0;
+    // Returns the file with filename matching name. Returns nullptr if directory dosen't have a
+    // file with name.
+    virtual std::shared_ptr<VfsFile> GetFile(const std::string& name) const;
+
+    // Returns a vector containing all of the subdirectories in this directory.
+    virtual std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const = 0;
+    // Returns the directory with name matching name. Returns nullptr if directory dosen't have a
+    // directory with name.
+    virtual std::shared_ptr<VfsDirectory> GetSubdirectory(const std::string& name) const;
+
+    // Returns whether or not the directory can be written to.
+    virtual bool IsWritable() const = 0;
+    // Returns whether of not the directory can be read from.
+    virtual bool IsReadable() const = 0;
+
+    // Returns whether or not the directory is the root of the current file tree.
+    virtual bool IsRoot() const;
+
+    // Returns the name of the directory.
+    virtual std::string GetName() const = 0;
+    // Returns the total size of all files and subdirectories in this directory.
+    virtual size_t GetSize() const;
+    // Returns the parent directory of this directory. Returns nullptr if this directory is root or
+    // has no parent.
+    virtual std::shared_ptr<VfsDirectory> GetParentDirectory() const = 0;
+
+    // Creates a new subdirectory with name name. Returns a pointer to the new directory or nullptr
+    // if the operation failed.
+    virtual std::shared_ptr<VfsDirectory> CreateSubdirectory(const std::string& name) = 0;
+    // Creates a new file with name name. Returns a pointer to the new file or nullptr if the
+    // operation failed.
+    virtual std::shared_ptr<VfsFile> CreateFile(const std::string& name) = 0;
+
+    // Creates a new file at the path relative to this directory. Also creates directories if
+    // they do not exist and is supported by this implementation. Returns nullptr on any failure.
+    virtual std::shared_ptr<VfsFile> CreateFileRelative(const std::string& path);
+
+    // Creates a new file at the path relative to root of this directory. Also creates directories
+    // if they do not exist and is supported by this implementation. Returns nullptr on any failure.
+    virtual std::shared_ptr<VfsFile> CreateFileAbsolute(const std::string& path);
+
+    // Creates a new directory at the path relative to this directory. Also creates directories if
+    // they do not exist and is supported by this implementation. Returns nullptr on any failure.
+    virtual std::shared_ptr<VfsDirectory> CreateDirectoryRelative(const std::string& path);
+
+    // Creates a new directory at the path relative to root of this directory. Also creates
+    // directories if they do not exist and is supported by this implementation. Returns nullptr on
+    // any failure.
+    virtual std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(const std::string& path);
+
+    // Deletes the subdirectory with name and returns true on success.
+    virtual bool DeleteSubdirectory(const std::string& name) = 0;
+    // Deletes all subdirectories and files of subdirectory with name recirsively and then deletes
+    // the subdirectory. Returns true on success.
+    virtual bool DeleteSubdirectoryRecursive(const std::string& name);
+    // Returnes whether or not the file with name name was deleted successfully.
+    virtual bool DeleteFile(const std::string& name) = 0;
+
+    // Returns whether or not this directory was renamed to name.
+    virtual bool Rename(const std::string& name) = 0;
+
+    // Returns whether or not the file with name src was successfully copied to a new file with name
+    // dest.
+    virtual bool Copy(const std::string& src, const std::string& dest);
+
+    // Interprets the file with name file instead as a directory of type directory.
+    // The directory must have a constructor that takes a single argument of type
+    // std::shared_ptr<VfsFile>. Allows to reinterpret container files (i.e NCA, zip, XCI, etc) as a
+    // subdirectory in one call.
+    template <typename Directory>
+    bool InterpretAsDirectory(const std::string& file) {
+        auto file_p = GetFile(file);
+        if (file_p == nullptr)
+            return false;
+        return ReplaceFileWithSubdirectory(file, std::make_shared<Directory>(file_p));
+    }
+
+protected:
+    // Backend for InterpretAsDirectory.
+    // Removes all references to file and adds a reference to dir in the directory's implementation.
+    virtual bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) = 0;
+};
+
+// A convenience partial-implementation of VfsDirectory that stubs out methods that should only work
+// if writable. This is to avoid redundant empty methods everywhere.
+struct ReadOnlyVfsDirectory : public VfsDirectory {
+    bool IsWritable() const override;
+    bool IsReadable() const override;
+    std::shared_ptr<VfsDirectory> CreateSubdirectory(const std::string& name) override;
+    std::shared_ptr<VfsFile> CreateFile(const std::string& name) override;
+    bool DeleteSubdirectory(const std::string& name) override;
+    bool DeleteFile(const std::string& name) override;
+    bool Rename(const std::string& name) override;
+};
+} // namespace FileSys

src/core/file_sys/vfs_offset.cpp

@@ -0,0 +1,92 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/file_sys/vfs_offset.h"
+
+namespace FileSys {
+
+OffsetVfsFile::OffsetVfsFile(std::shared_ptr<VfsFile> file_, size_t size_, size_t offset_,
+                             const std::string& name_)
+    : file(file_), offset(offset_), size(size_), name(name_) {}
+
+std::string OffsetVfsFile::GetName() const {
+    return name.empty() ? file->GetName() : name;
+}
+
+size_t OffsetVfsFile::GetSize() const {
+    return size;
+}
+
+bool OffsetVfsFile::Resize(size_t new_size) {
+    if (offset + new_size < file->GetSize()) {
+        size = new_size;
+    } else {
+        auto res = file->Resize(offset + new_size);
+        if (!res)
+            return false;
+        size = new_size;
+    }
+
+    return true;
+}
+
+std::shared_ptr<VfsDirectory> OffsetVfsFile::GetContainingDirectory() const {
+    return file->GetContainingDirectory();
+}
+
+bool OffsetVfsFile::IsWritable() const {
+    return file->IsWritable();
+}
+
+bool OffsetVfsFile::IsReadable() const {
+    return file->IsReadable();
+}
+
+size_t OffsetVfsFile::Read(u8* data, size_t length, size_t r_offset) const {
+    return file->Read(data, TrimToFit(length, r_offset), offset + r_offset);
+}
+
+size_t OffsetVfsFile::Write(const u8* data, size_t length, size_t r_offset) {
+    return file->Write(data, TrimToFit(length, r_offset), offset + r_offset);
+}
+
+boost::optional<u8> OffsetVfsFile::ReadByte(size_t r_offset) const {
+    if (r_offset < size)
+        return file->ReadByte(offset + r_offset);
+
+    return boost::none;
+}
+
+std::vector<u8> OffsetVfsFile::ReadBytes(size_t r_size, size_t r_offset) const {
+    return file->ReadBytes(TrimToFit(r_size, r_offset), offset + r_offset);
+}
+
+std::vector<u8> OffsetVfsFile::ReadAllBytes() const {
+    return file->ReadBytes(size, offset);
+}
+
+bool OffsetVfsFile::WriteByte(u8 data, size_t r_offset) {
+    if (r_offset < size)
+        return file->WriteByte(data, offset + r_offset);
+
+    return false;
+}
+
+size_t OffsetVfsFile::WriteBytes(std::vector<u8> data, size_t r_offset) {
+    return file->Write(data.data(), TrimToFit(data.size(), r_offset), offset + r_offset);
+}
+
+bool OffsetVfsFile::Rename(const std::string& name) {
+    return file->Rename(name);
+}
+
+size_t OffsetVfsFile::GetOffset() const {
+    return offset;
+}
+
+size_t OffsetVfsFile::TrimToFit(size_t r_size, size_t r_offset) const {
+    return std::max<size_t>(std::min<size_t>(size - r_offset, r_size), 0);
+}
+
+} // namespace FileSys

src/core/file_sys/vfs_offset.h

@@ -0,0 +1,46 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/file_sys/vfs.h"
+
+namespace FileSys {
+
+// An implementation of VfsFile that wraps around another VfsFile at a certain offset.
+// Similar to seeking to an offset.
+// If the file is writable, operations that would write past the end of the offset file will expand
+// the size of this wrapper.
+struct OffsetVfsFile : public VfsFile {
+    OffsetVfsFile(std::shared_ptr<VfsFile> file, size_t size, size_t offset = 0,
+                  const std::string& new_name = "");
+
+    std::string GetName() const override;
+    size_t GetSize() const override;
+    bool Resize(size_t new_size) override;
+    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    bool IsWritable() const override;
+    bool IsReadable() const override;
+    size_t Read(u8* data, size_t length, size_t offset) const override;
+    size_t Write(const u8* data, size_t length, size_t offset) override;
+    boost::optional<u8> ReadByte(size_t offset) const override;
+    std::vector<u8> ReadBytes(size_t size, size_t offset) const override;
+    std::vector<u8> ReadAllBytes() const override;
+    bool WriteByte(u8 data, size_t offset) override;
+    size_t WriteBytes(std::vector<u8> data, size_t offset) override;
+
+    bool Rename(const std::string& name) override;
+
+    size_t GetOffset() const;
+
+private:
+    size_t TrimToFit(size_t r_size, size_t r_offset) const;
+
+    std::shared_ptr<VfsFile> file;
+    size_t offset;
+    size_t size;
+    std::string name;
+};
+
+} // namespace FileSys

src/core/file_sys/vfs_real.cpp

@@ -0,0 +1,177 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/common_paths.h"
+#include "common/logging/log.h"
+#include "core/file_sys/vfs_real.h"
+
+namespace FileSys {
+
+static std::string PermissionsToCharArray(Mode perms) {
+    std::string out;
+    switch (perms) {
+    case Mode::Read:
+        out += "r";
+        break;
+    case Mode::Write:
+        out += "r+";
+        break;
+    case Mode::Append:
+        out += "a";
+        break;
+    }
+    return out + "b";
+}
+
+RealVfsFile::RealVfsFile(const std::string& path_, Mode perms_)
+    : backing(path_, PermissionsToCharArray(perms_).c_str()), path(path_),
+      parent_path(FileUtil::GetParentPath(path_)),
+      path_components(FileUtil::SplitPathComponents(path_)),
+      parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
+      perms(perms_) {}
+
+std::string RealVfsFile::GetName() const {
+    return path_components.back();
+}
+
+size_t RealVfsFile::GetSize() const {
+    return backing.GetSize();
+}
+
+bool RealVfsFile::Resize(size_t new_size) {
+    return backing.Resize(new_size);
+}
+
+std::shared_ptr<VfsDirectory> RealVfsFile::GetContainingDirectory() const {
+    return std::make_shared<RealVfsDirectory>(parent_path, perms);
+}
+
+bool RealVfsFile::IsWritable() const {
+    return perms == Mode::Append || perms == Mode::Write;
+}
+
+bool RealVfsFile::IsReadable() const {
+    return perms == Mode::Read || perms == Mode::Write;
+}
+
+size_t RealVfsFile::Read(u8* data, size_t length, size_t offset) const {
+    if (!backing.Seek(offset, SEEK_SET))
+        return 0;
+    return backing.ReadBytes(data, length);
+}
+
+size_t RealVfsFile::Write(const u8* data, size_t length, size_t offset) {
+    if (!backing.Seek(offset, SEEK_SET))
+        return 0;
+    return backing.WriteBytes(data, length);
+}
+
+bool RealVfsFile::Rename(const std::string& name) {
+    const auto out = FileUtil::Rename(GetName(), name);
+    path = parent_path + DIR_SEP + name;
+    path_components = parent_components;
+    path_components.push_back(name);
+    backing = FileUtil::IOFile(path, PermissionsToCharArray(perms).c_str());
+    return out;
+}
+
+bool RealVfsFile::Close() {
+    return backing.Close();
+}
+
+RealVfsDirectory::RealVfsDirectory(const std::string& path_, Mode perms_)
+    : path(FileUtil::RemoveTrailingSlash(path_)), parent_path(FileUtil::GetParentPath(path)),
+      path_components(FileUtil::SplitPathComponents(path)),
+      parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
+      perms(perms_) {
+    if (!FileUtil::Exists(path) && (perms == Mode::Write || perms == Mode::Append))
+        FileUtil::CreateDir(path);
+    unsigned size;
+    if (perms == Mode::Append)
+        return;
+
+    FileUtil::ForeachDirectoryEntry(
+        &size, path,
+        [this](unsigned* entries_out, const std::string& directory, const std::string& filename) {
+            std::string full_path = directory + DIR_SEP + filename;
+            if (FileUtil::IsDirectory(full_path))
+                subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(full_path, perms));
+            else
+                files.emplace_back(std::make_shared<RealVfsFile>(full_path, perms));
+            return true;
+        });
+}
+
+std::vector<std::shared_ptr<VfsFile>> RealVfsDirectory::GetFiles() const {
+    return std::vector<std::shared_ptr<VfsFile>>(files);
+}
+
+std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories() const {
+    return std::vector<std::shared_ptr<VfsDirectory>>(subdirectories);
+}
+
+bool RealVfsDirectory::IsWritable() const {
+    return perms == Mode::Write || perms == Mode::Append;
+}
+
+bool RealVfsDirectory::IsReadable() const {
+    return perms == Mode::Read || perms == Mode::Write;
+}
+
+std::string RealVfsDirectory::GetName() const {
+    return path_components.back();
+}
+
+std::shared_ptr<VfsDirectory> RealVfsDirectory::GetParentDirectory() const {
+    if (path_components.size() <= 1)
+        return nullptr;
+
+    return std::make_shared<RealVfsDirectory>(parent_path, perms);
+}
+
+std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateSubdirectory(const std::string& name) {
+    if (!FileUtil::CreateDir(path + DIR_SEP + name))
+        return nullptr;
+    subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(path + DIR_SEP + name, perms));
+    return subdirectories.back();
+}
+
+std::shared_ptr<VfsFile> RealVfsDirectory::CreateFile(const std::string& name) {
+    if (!FileUtil::CreateEmptyFile(path + DIR_SEP + name))
+        return nullptr;
+    files.emplace_back(std::make_shared<RealVfsFile>(path + DIR_SEP + name, perms));
+    return files.back();
+}
+
+bool RealVfsDirectory::DeleteSubdirectory(const std::string& name) {
+    return FileUtil::DeleteDirRecursively(path + DIR_SEP + name);
+}
+
+bool RealVfsDirectory::DeleteFile(const std::string& name) {
+    auto file = GetFile(name);
+    if (file == nullptr)
+        return false;
+    files.erase(std::find(files.begin(), files.end(), file));
+    auto real_file = std::static_pointer_cast<RealVfsFile>(file);
+    real_file->Close();
+    return FileUtil::Delete(path + DIR_SEP + name);
+}
+
+bool RealVfsDirectory::Rename(const std::string& name) {
+    return FileUtil::Rename(path, parent_path + DIR_SEP + name);
+}
+
+bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    auto iter = std::find(files.begin(), files.end(), file);
+    if (iter == files.end())
+        return false;
+
+    files[iter - files.begin()] = files.back();
+    files.pop_back();
+
+    subdirectories.emplace_back(dir);
+
+    return true;
+}
+} // namespace FileSys

src/core/file_sys/vfs_real.h

@@ -0,0 +1,69 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/file_util.h"
+#include "core/file_sys/mode.h"
+#include "core/file_sys/vfs.h"
+
+namespace FileSys {
+
+// An implmentation of VfsFile that represents a file on the user's computer.
+struct RealVfsFile : public VfsFile {
+    friend struct RealVfsDirectory;
+
+    RealVfsFile(const std::string& name, Mode perms = Mode::Read);
+
+    std::string GetName() const override;
+    size_t GetSize() const override;
+    bool Resize(size_t new_size) override;
+    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    bool IsWritable() const override;
+    bool IsReadable() const override;
+    size_t Read(u8* data, size_t length, size_t offset) const override;
+    size_t Write(const u8* data, size_t length, size_t offset) override;
+    bool Rename(const std::string& name) override;
+
+private:
+    bool Close();
+
+    FileUtil::IOFile backing;
+    std::string path;
+    std::string parent_path;
+    std::vector<std::string> path_components;
+    std::vector<std::string> parent_components;
+    Mode perms;
+};
+
+// An implementation of VfsDirectory that represents a directory on the user's computer.
+struct RealVfsDirectory : public VfsDirectory {
+    RealVfsDirectory(const std::string& path, Mode perms);
+
+    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    bool IsWritable() const override;
+    bool IsReadable() const override;
+    std::string GetName() const override;
+    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    std::shared_ptr<VfsDirectory> CreateSubdirectory(const std::string& name) override;
+    std::shared_ptr<VfsFile> CreateFile(const std::string& name) override;
+    bool DeleteSubdirectory(const std::string& name) override;
+    bool DeleteFile(const std::string& name) override;
+    bool Rename(const std::string& name) override;
+
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
+private:
+    std::string path;
+    std::string parent_path;
+    std::vector<std::string> path_components;
+    std::vector<std::string> parent_components;
+    Mode perms;
+    std::vector<std::shared_ptr<VfsFile>> files;
+    std::vector<std::shared_ptr<VfsDirectory>> subdirectories;
+};
+
+} // namespace FileSys

src/core/frontend/input.h

@@ -59,7 +59,7 @@ template <typename InputDeviceType>
 void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDeviceType>> factory) {
     auto pair = std::make_pair(name, std::move(factory));
     if (!Impl::FactoryList<InputDeviceType>::list.insert(std::move(pair)).second) {
-        LOG_ERROR(Input, "Factory %s already registered", name.c_str());
+        LOG_ERROR(Input, "Factory '{}' already registered", name);
     }
 }
 
@@ -71,7 +71,7 @@ void RegisterFactory(const std::string& name, std::shared_ptr<Factory<InputDevic
 template <typename InputDeviceType>
 void UnregisterFactory(const std::string& name) {
     if (Impl::FactoryList<InputDeviceType>::list.erase(name) == 0) {
-        LOG_ERROR(Input, "Factory %s not registered", name.c_str());
+        LOG_ERROR(Input, "Factory '{}' not registered", name);
     }
 }
 
@@ -88,7 +88,7 @@ std::unique_ptr<InputDeviceType> CreateDevice(const std::string& params) {
     const auto pair = factory_list.find(engine);
     if (pair == factory_list.end()) {
         if (engine != "null") {
-            LOG_ERROR(Input, "Unknown engine name: %s", engine.c_str());
+            LOG_ERROR(Input, "Unknown engine name: {}", engine);
         }
         return std::make_unique<InputDeviceType>();
     }

src/core/gdbstub/gdbstub.cpp

@@ -6,7 +6,6 @@
 
 #include <algorithm>
 #include <atomic>
-#include <cinttypes>
 #include <climits>
 #include <csignal>
 #include <cstdarg>
@@ -33,9 +32,13 @@
 
 #include "common/logging/log.h"
 #include "common/string_util.h"
+#include "common/swap.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
+#include "core/core_cpu.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 
@@ -58,10 +61,16 @@ const u32 SIGTERM = 15;
 const u32 MSG_WAITALL = 8;
 #endif
 
-const u32 X30_REGISTER = 30;
+const u32 LR_REGISTER = 30;
 const u32 SP_REGISTER = 31;
 const u32 PC_REGISTER = 32;
 const u32 CPSR_REGISTER = 33;
+const u32 UC_ARM64_REG_Q0 = 34;
+const u32 FPSCR_REGISTER = 66;
+
+// TODO/WiP - Used while working on support for FPU
+const u32 TODO_DUMMY_REG_997 = 997;
+const u32 TODO_DUMMY_REG_998 = 998;
 
 // For sample XML files see the GDB source /gdb/features
 // GDB also wants the l character at the start
@@ -127,6 +136,8 @@ static const char* target_xml =
     </flags>
     <reg name="cpsr" bitsize="32" type="cpsr_flags"/>
   </feature>
+  <feature name="org.gnu.gdb.aarch64.fpu">
+  </feature>
 </target>
 )";
 
@@ -138,15 +149,18 @@ static u8 command_buffer[GDB_BUFFER_SIZE];
 static u32 command_length;
 
 static u32 latest_signal = 0;
-static bool step_break = false;
 static bool memory_break = false;
 
+static Kernel::Thread* current_thread = nullptr;
+static u32 current_core = 0;
+
 // Binding to a port within the reserved ports range (0-1023) requires root permissions,
 // so default to a port outside of that range.
 static u16 gdbstub_port = 24689;
 
 static bool halt_loop = true;
 static bool step_loop = false;
+static bool send_trap = false;
 
 // If set to false, the server will never be started and no
 // gdbstub-related functions will be executed.
@@ -166,6 +180,78 @@ static std::map<u64, Breakpoint> breakpoints_execute;
 static std::map<u64, Breakpoint> breakpoints_read;
 static std::map<u64, Breakpoint> breakpoints_write;
 
+struct Module {
+    std::string name;
+    PAddr beg;
+    PAddr end;
+};
+
+static std::vector<Module> modules;
+
+void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext) {
+    Module module;
+    if (add_elf_ext) {
+        Common::SplitPath(name, nullptr, &module.name, nullptr);
+        module.name += ".elf";
+    } else {
+        module.name = std::move(name);
+    }
+    module.beg = beg;
+    module.end = end;
+    modules.push_back(std::move(module));
+}
+
+static Kernel::Thread* FindThreadById(int id) {
+    for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+        const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+        for (auto& thread : threads) {
+            if (thread->GetThreadId() == id) {
+                current_core = core;
+                return thread.get();
+            }
+        }
+    }
+    return nullptr;
+}
+
+static u64 RegRead(int id, Kernel::Thread* thread = nullptr) {
+    if (!thread) {
+        return 0;
+    }
+
+    if (id < SP_REGISTER) {
+        return thread->context.cpu_registers[id];
+    } else if (id == SP_REGISTER) {
+        return thread->context.sp;
+    } else if (id == PC_REGISTER) {
+        return thread->context.pc;
+    } else if (id == CPSR_REGISTER) {
+        return thread->context.cpsr;
+    } else if (id > CPSR_REGISTER && id < FPSCR_REGISTER) {
+        return thread->context.fpu_registers[id - UC_ARM64_REG_Q0][0];
+    } else {
+        return 0;
+    }
+}
+
+static void RegWrite(int id, u64 val, Kernel::Thread* thread = nullptr) {
+    if (!thread) {
+        return;
+    }
+
+    if (id < SP_REGISTER) {
+        thread->context.cpu_registers[id] = val;
+    } else if (id == SP_REGISTER) {
+        thread->context.sp = val;
+    } else if (id == PC_REGISTER) {
+        thread->context.pc = val;
+    } else if (id == CPSR_REGISTER) {
+        thread->context.cpsr = val;
+    } else if (id > CPSR_REGISTER && id < FPSCR_REGISTER) {
+        thread->context.fpu_registers[id - (CPSR_REGISTER + 1)][0] = val;
+    }
+}
+
 /**
  * Turns hex string character into the equivalent byte.
  *
@@ -180,7 +266,7 @@ static u8 HexCharToValue(u8 hex) {
         return hex - 'A' + 0xA;
     }
 
-    LOG_ERROR(Debug_GDBStub, "Invalid nibble: %c (%02x)\n", hex, hex);
+    LOG_ERROR(Debug_GDBStub, "Invalid nibble: {} ({:02X})", hex, hex);
     return 0;
 }
 
@@ -194,7 +280,7 @@ static u8 NibbleToHex(u8 n) {
     if (n < 0xA) {
         return '0' + n;
     } else {
-        return 'A' + n - 0xA;
+        return 'a' + n - 0xA;
     }
 }
 
@@ -320,7 +406,7 @@ static u8 ReadByte() {
     u8 c;
     size_t received_size = recv(gdbserver_socket, reinterpret_cast<char*>(&c), 1, MSG_WAITALL);
     if (received_size != 1) {
-        LOG_ERROR(Debug_GDBStub, "recv failed : %ld", received_size);
+        LOG_ERROR(Debug_GDBStub, "recv failed: {}", received_size);
         Shutdown();
     }
 
@@ -361,8 +447,7 @@ static void RemoveBreakpoint(BreakpointType type, PAddr addr) {
 
     auto bp = p.find(static_cast<u64>(addr));
     if (bp != p.end()) {
-        LOG_DEBUG(Debug_GDBStub,
-                  "gdb: removed a breakpoint: %016" PRIx64 " bytes at %016" PRIx64 " of type %d\n",
+        LOG_DEBUG(Debug_GDBStub, "gdb: removed a breakpoint: {:016X} bytes at {:016X} of type {}",
                   bp->second.len, bp->second.addr, static_cast<int>(type));
         p.erase(static_cast<u64>(addr));
     }
@@ -409,8 +494,8 @@ bool CheckBreakpoint(PAddr addr, BreakpointType type) {
 
         if (bp->second.active && (addr >= bp->second.addr && addr < bp->second.addr + len)) {
             LOG_DEBUG(Debug_GDBStub,
-                      "Found breakpoint type %d @ %016" PRIx64 ", range: %016" PRIx64
-                      " - %016" PRIx64 " (%" PRIx64 " bytes)\n",
+                      "Found breakpoint type {} @ {:016X}, range: {:016X}"
+                      " - {:016X} ({:X} bytes)",
                       static_cast<int>(type), addr, bp->second.addr, bp->second.addr + len, len);
             return true;
         }
@@ -441,6 +526,8 @@ static void SendReply(const char* reply) {
         return;
     }
 
+    LOG_DEBUG(Debug_GDBStub, "Reply: {}", reply);
+
     memset(command_buffer, 0, sizeof(command_buffer));
 
     command_length = static_cast<u32>(strlen(reply));
@@ -473,7 +560,7 @@ static void SendReply(const char* reply) {
 
 /// Handle query command from gdb client.
 static void HandleQuery() {
-    LOG_DEBUG(Debug_GDBStub, "gdb: query '%s'\n", command_buffer + 1);
+    LOG_DEBUG(Debug_GDBStub, "gdb: query '{}'", command_buffer + 1);
 
     const char* query = reinterpret_cast<const char*>(command_buffer + 1);
 
@@ -481,10 +568,55 @@ static void HandleQuery() {
         SendReply("T0");
     } else if (strncmp(query, "Supported", strlen("Supported")) == 0) {
         // PacketSize needs to be large enough for target xml
-        SendReply("PacketSize=2000;qXfer:features:read+");
+        std::string buffer = "PacketSize=2000;qXfer:features:read+;qXfer:threads:read+";
+        if (!modules.empty()) {
+            buffer += ";qXfer:libraries:read+";
+        }
+        SendReply(buffer.c_str());
     } else if (strncmp(query, "Xfer:features:read:target.xml:",
                        strlen("Xfer:features:read:target.xml:")) == 0) {
         SendReply(target_xml);
+    } else if (strncmp(query, "Offsets", strlen("Offsets")) == 0) {
+        std::string buffer = fmt::format("TextSeg={:0x}", Memory::PROCESS_IMAGE_VADDR);
+        SendReply(buffer.c_str());
+    } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
+        std::string val = "m";
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+            for (const auto& thread : threads) {
+                val += fmt::format("{:x}", thread->GetThreadId());
+                val += ",";
+            }
+        }
+        val.pop_back();
+        SendReply(val.c_str());
+    } else if (strncmp(query, "sThreadInfo", strlen("sThreadInfo")) == 0) {
+        SendReply("l");
+    } else if (strncmp(query, "Xfer:threads:read", strlen("Xfer:threads:read")) == 0) {
+        std::string buffer;
+        buffer += "l<?xml version=\"1.0\"?>";
+        buffer += "<threads>";
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+            for (const auto& thread : threads) {
+                buffer +=
+                    fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
+                                thread->GetThreadId(), core, thread->GetThreadId());
+            }
+        }
+        buffer += "</threads>";
+        SendReply(buffer.c_str());
+    } else if (strncmp(query, "Xfer:libraries:read", strlen("Xfer:libraries:read")) == 0) {
+        std::string buffer;
+        buffer += "l<?xml version=\"1.0\"?>";
+        buffer += "<library-list>";
+        for (const auto& module : modules) {
+            buffer +=
+                fmt::format(R"*("<library name = "{}"><segment address = "0x{:x}"/></library>)*",
+                            module.name, module.beg);
+        }
+        buffer += "</library-list>";
+        SendReply(buffer.c_str());
     } else {
         SendReply("");
     }
@@ -492,11 +624,34 @@ static void HandleQuery() {
 
 /// Handle set thread command from gdb client.
 static void HandleSetThread() {
-    if (memcmp(command_buffer, "Hg0", 3) == 0 || memcmp(command_buffer, "Hc-1", 4) == 0 ||
-        memcmp(command_buffer, "Hc0", 4) == 0 || memcmp(command_buffer, "Hc1", 4) == 0) {
-        return SendReply("OK");
+    int thread_id = -1;
+    if (command_buffer[2] != '-') {
+        thread_id = static_cast<int>(HexToInt(command_buffer + 2, command_length - 2));
     }
+    if (thread_id >= 1) {
+        current_thread = FindThreadById(thread_id);
+    }
+    if (!current_thread) {
+        thread_id = 1;
+        current_thread = FindThreadById(thread_id);
+    }
+    if (current_thread) {
+        SendReply("OK");
+        return;
+    }
+    SendReply("E01");
+}
 
+/// Handle thread alive command from gdb client.
+static void HandleThreadAlive() {
+    int thread_id = static_cast<int>(HexToInt(command_buffer + 1, command_length - 1));
+    if (thread_id == 0) {
+        thread_id = 1;
+    }
+    if (FindThreadById(thread_id)) {
+        SendReply("OK");
+        return;
+    }
     SendReply("E01");
 }
 
@@ -505,15 +660,31 @@ static void HandleSetThread() {
  *
  * @param signal Signal to be sent to client.
  */
-static void SendSignal(u32 signal) {
+static void SendSignal(Kernel::Thread* thread, u32 signal, bool full = true) {
     if (gdbserver_socket == -1) {
         return;
     }
 
     latest_signal = signal;
 
-    std::string buffer = Common::StringFromFormat("T%02x", latest_signal);
-    LOG_DEBUG(Debug_GDBStub, "Response: %s", buffer.c_str());
+    if (!thread) {
+        full = false;
+    }
+
+    std::string buffer;
+    if (full) {
+        buffer = fmt::format("T{:02x}{:02x}:{:016x};{:02x}:{:016x};{:02x}:{:016x}", latest_signal,
+                             PC_REGISTER, Common::swap64(RegRead(PC_REGISTER, thread)), SP_REGISTER,
+                             Common::swap64(RegRead(SP_REGISTER, thread)), LR_REGISTER,
+                             Common::swap64(RegRead(LR_REGISTER, thread)));
+    } else {
+        buffer = fmt::format("T{:02x}", latest_signal);
+    }
+
+    if (thread) {
+        buffer += fmt::format(";thread:{:x};", thread->GetThreadId());
+    }
+
     SendReply(buffer.c_str());
 }
 
@@ -527,18 +698,18 @@ static void ReadCommand() {
         // ignore ack
         return;
     } else if (c == 0x03) {
-        LOG_INFO(Debug_GDBStub, "gdb: found break command\n");
+        LOG_INFO(Debug_GDBStub, "gdb: found break command");
         halt_loop = true;
-        SendSignal(SIGTRAP);
+        SendSignal(current_thread, SIGTRAP);
         return;
     } else if (c != GDB_STUB_START) {
-        LOG_DEBUG(Debug_GDBStub, "gdb: read invalid byte %02x\n", c);
+        LOG_DEBUG(Debug_GDBStub, "gdb: read invalid byte {:02X}", c);
         return;
     }
 
     while ((c = ReadByte()) != GDB_STUB_END) {
         if (command_length >= sizeof(command_buffer)) {
-            LOG_ERROR(Debug_GDBStub, "gdb: command_buffer overflow\n");
+            LOG_ERROR(Debug_GDBStub, "gdb: command_buffer overflow");
             SendPacket(GDB_STUB_NACK);
             return;
         }
@@ -552,7 +723,7 @@ static void ReadCommand() {
 
     if (checksum_received != checksum_calculated) {
         LOG_ERROR(Debug_GDBStub,
-                  "gdb: invalid checksum: calculated %02x and read %02x for $%s# (length: %d)\n",
+                  "gdb: invalid checksum: calculated {:02X} and read {:02X} for ${}# (length: {})",
                   checksum_calculated, checksum_received, command_buffer, command_length);
 
         command_length = 0;
@@ -599,13 +770,17 @@ static void ReadRegister() {
     }
 
     if (id <= SP_REGISTER) {
-        LongToGdbHex(reply, Core::CPU().GetReg(static_cast<int>(id)));
+        LongToGdbHex(reply, RegRead(id, current_thread));
     } else if (id == PC_REGISTER) {
-        LongToGdbHex(reply, Core::CPU().GetPC());
+        LongToGdbHex(reply, RegRead(id, current_thread));
     } else if (id == CPSR_REGISTER) {
-        IntToGdbHex(reply, Core::CPU().GetCPSR());
+        IntToGdbHex(reply, (u32)RegRead(id, current_thread));
+    } else if (id >= UC_ARM64_REG_Q0 && id < FPSCR_REGISTER) {
+        LongToGdbHex(reply, RegRead(id, current_thread));
+    } else if (id == FPSCR_REGISTER) {
+        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_998, current_thread));
     } else {
-        return SendReply("E01");
+        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_997, current_thread));
     }
 
     SendReply(reinterpret_cast<char*>(reply));
@@ -619,16 +794,26 @@ static void ReadRegisters() {
     u8* bufptr = buffer;
 
     for (int reg = 0; reg <= SP_REGISTER; reg++) {
-        LongToGdbHex(bufptr + reg * 16, Core::CPU().GetReg(reg));
+        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
     }
 
-    bufptr += (32 * 16);
+    bufptr += 32 * 16;
 
-    LongToGdbHex(bufptr, Core::CPU().GetPC());
+    LongToGdbHex(bufptr, RegRead(PC_REGISTER, current_thread));
 
     bufptr += 16;
 
-    IntToGdbHex(bufptr, Core::CPU().GetCPSR());
+    IntToGdbHex(bufptr, (u32)RegRead(CPSR_REGISTER, current_thread));
+
+    bufptr += 8;
+
+    for (int reg = UC_ARM64_REG_Q0; reg <= UC_ARM64_REG_Q0 + 31; reg++) {
+        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
+    }
+
+    bufptr += 32 * 32;
+
+    LongToGdbHex(bufptr, RegRead(TODO_DUMMY_REG_998, current_thread));
 
     bufptr += 8;
 
@@ -647,15 +832,22 @@ static void WriteRegister() {
     }
 
     if (id <= SP_REGISTER) {
-        Core::CPU().SetReg(id, GdbHexToLong(buffer_ptr));
+        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
     } else if (id == PC_REGISTER) {
-        Core::CPU().SetPC(GdbHexToLong(buffer_ptr));
+        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
     } else if (id == CPSR_REGISTER) {
-        Core::CPU().SetCPSR(GdbHexToInt(buffer_ptr));
+        RegWrite(id, GdbHexToInt(buffer_ptr), current_thread);
+    } else if (id >= UC_ARM64_REG_Q0 && id < FPSCR_REGISTER) {
+        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
+    } else if (id == FPSCR_REGISTER) {
+        RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr), current_thread);
     } else {
-        return SendReply("E01");
+        RegWrite(TODO_DUMMY_REG_997, GdbHexToLong(buffer_ptr), current_thread);
     }
 
+    // Update Unicorn context skipping scheduler, no running threads at this point
+    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+
     SendReply("OK");
 }
 
@@ -666,18 +858,25 @@ static void WriteRegisters() {
     if (command_buffer[0] != 'G')
         return SendReply("E01");
 
-    for (int i = 0, reg = 0; reg <= CPSR_REGISTER; i++, reg++) {
+    for (int i = 0, reg = 0; reg <= FPSCR_REGISTER; i++, reg++) {
         if (reg <= SP_REGISTER) {
-            Core::CPU().SetReg(reg, GdbHexToLong(buffer_ptr + i * 16));
+            RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else if (reg == PC_REGISTER) {
-            Core::CPU().SetPC(GdbHexToLong(buffer_ptr + i * 16));
+            RegWrite(PC_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else if (reg == CPSR_REGISTER) {
-            Core::CPU().SetCPSR(GdbHexToInt(buffer_ptr + i * 16));
+            RegWrite(CPSR_REGISTER, GdbHexToInt(buffer_ptr + i * 16), current_thread);
+        } else if (reg >= UC_ARM64_REG_Q0 && reg < FPSCR_REGISTER) {
+            RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
+        } else if (reg == FPSCR_REGISTER) {
+            RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else {
             UNIMPLEMENTED();
         }
     }
 
+    // Update Unicorn context skipping scheduler, no running threads at this point
+    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+
     SendReply("OK");
 }
 
@@ -693,12 +892,16 @@ static void ReadMemory() {
     u64 len =
         HexToLong(start_offset, static_cast<u64>((command_buffer + command_length) - start_offset));
 
-    LOG_DEBUG(Debug_GDBStub, "gdb: addr: %016lx len: %016lx\n", addr, len);
+    LOG_DEBUG(Debug_GDBStub, "gdb: addr: {:016X} len: {:016X}", addr, len);
 
     if (len * 2 > sizeof(reply)) {
         SendReply("E01");
     }
 
+    if (addr < Memory::PROCESS_IMAGE_VADDR || addr >= Memory::MAP_REGION_VADDR_END) {
+        return SendReply("E00");
+    }
+
     if (!Memory::IsValidVirtualAddress(addr)) {
         return SendReply("E00");
     }
@@ -733,22 +936,24 @@ static void WriteMemory() {
 }
 
 void Break(bool is_memory_break) {
-    if (!halt_loop) {
-        halt_loop = true;
-        SendSignal(SIGTRAP);
-    }
+    send_trap = true;
 
     memory_break = is_memory_break;
 }
 
 /// Tell the CPU that it should perform a single step.
 static void Step() {
+    if (command_length > 1) {
+        RegWrite(PC_REGISTER, GdbHexToLong(command_buffer + 1), current_thread);
+        // Update Unicorn context skipping scheduler, no running threads at this point
+        Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+    }
     step_loop = true;
     halt_loop = true;
-    step_break = true;
-    SendSignal(SIGTRAP);
+    send_trap = true;
 }
 
+/// Tell the CPU if we hit a memory breakpoint.
 bool IsMemoryBreak() {
     if (IsConnected()) {
         return false;
@@ -760,7 +965,6 @@ bool IsMemoryBreak() {
 /// Tell the CPU to continue executing.
 static void Continue() {
     memory_break = false;
-    step_break = false;
     step_loop = false;
     halt_loop = false;
 }
@@ -781,7 +985,7 @@ static bool CommitBreakpoint(BreakpointType type, PAddr addr, u64 len) {
     breakpoint.len = len;
     p.insert({addr, breakpoint});
 
-    LOG_DEBUG(Debug_GDBStub, "gdb: added %d breakpoint: %016" PRIx64 " bytes at %016" PRIx64 "\n",
+    LOG_DEBUG(Debug_GDBStub, "gdb: added {} breakpoint: {:016X} bytes at {:016X}",
               static_cast<int>(type), breakpoint.len, breakpoint.addr);
 
     return true;
@@ -889,7 +1093,7 @@ void HandlePacket() {
         return;
     }
 
-    LOG_DEBUG(Debug_GDBStub, "Packet: %s", command_buffer);
+    LOG_DEBUG(Debug_GDBStub, "Packet: {}", command_buffer);
 
     switch (command_buffer[0]) {
     case 'q':
@@ -899,7 +1103,7 @@ void HandlePacket() {
         HandleSetThread();
         break;
     case '?':
-        SendSignal(latest_signal);
+        SendSignal(current_thread, latest_signal);
         break;
     case 'k':
         Shutdown();
@@ -936,6 +1140,9 @@ void HandlePacket() {
     case 'Z':
         AddBreakpoint();
         break;
+    case 'T':
+        HandleThreadAlive();
+        break;
     default:
         SendReply("");
         break;
@@ -981,8 +1188,10 @@ static void Init(u16 port) {
     breakpoints_read.clear();
     breakpoints_write.clear();
 
+    modules.clear();
+
     // Start gdb server
-    LOG_INFO(Debug_GDBStub, "Starting GDB server on port %d...", port);
+    LOG_INFO(Debug_GDBStub, "Starting GDB server on port {}...", port);
 
     sockaddr_in saddr_server = {};
     saddr_server.sin_family = AF_INET;
@@ -1016,7 +1225,7 @@ static void Init(u16 port) {
     }
 
     // Wait for gdb to connect
-    LOG_INFO(Debug_GDBStub, "Waiting for gdb to connect...\n");
+    LOG_INFO(Debug_GDBStub, "Waiting for gdb to connect...");
     sockaddr_in saddr_client;
     sockaddr* client_addr = reinterpret_cast<sockaddr*>(&saddr_client);
     socklen_t client_addrlen = sizeof(saddr_client);
@@ -1029,7 +1238,7 @@ static void Init(u16 port) {
 
         LOG_ERROR(Debug_GDBStub, "Failed to accept gdb client");
     } else {
-        LOG_INFO(Debug_GDBStub, "Client connected.\n");
+        LOG_INFO(Debug_GDBStub, "Client connected.");
         saddr_client.sin_addr.s_addr = ntohl(saddr_client.sin_addr.s_addr);
     }
 
@@ -1080,4 +1289,15 @@ bool GetCpuStepFlag() {
 void SetCpuStepFlag(bool is_step) {
     step_loop = is_step;
 }
+
+void SendTrap(Kernel::Thread* thread, int trap) {
+    if (send_trap) {
+        if (!halt_loop || current_thread == thread) {
+            current_thread = thread;
+            SendSignal(thread, trap);
+        }
+        halt_loop = true;
+        send_trap = false;
+    }
+}
 }; // namespace GDBStub

src/core/gdbstub/gdbstub.h

@@ -6,7 +6,9 @@
 
 #pragma once
 
+#include <string>
 #include "common/common_types.h"
+#include "core/hle/kernel/thread.h"
 
 namespace GDBStub {
 
@@ -50,6 +52,9 @@ bool IsServerEnabled();
 /// Returns true if there is an active socket connection.
 bool IsConnected();
 
+/// Register module.
+void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext = true);
+
 /**
  * Signal to the gdbstub server that it should halt CPU execution.
  *
@@ -79,10 +84,10 @@ BreakpointAddress GetNextBreakpointFromAddress(PAddr addr, GDBStub::BreakpointTy
  */
 bool CheckBreakpoint(PAddr addr, GDBStub::BreakpointType type);
 
-// If set to true, the CPU will halt at the beginning of the next CPU loop.
+/// If set to true, the CPU will halt at the beginning of the next CPU loop.
 bool GetCpuHaltFlag();
 
-// If set to true and the CPU is halted, the CPU will step one instruction.
+/// If set to true and the CPU is halted, the CPU will step one instruction.
 bool GetCpuStepFlag();
 
 /**
@@ -91,4 +96,12 @@ bool GetCpuStepFlag();
  * @param is_step
  */
 void SetCpuStepFlag(bool is_step);
+
+/**
+ * Send trap signal from thread back to the gdbstub server.
+ *
+ * @param thread Sending thread.
+ * @param trap Trap no.
+ */
+void SendTrap(Kernel::Thread* thread, int trap);
 } // namespace GDBStub

src/core/hle/ipc.h

@@ -29,9 +29,14 @@ enum class ControlCommand : u32 {
 };
 
 enum class CommandType : u32 {
+    Invalid = 0,
+    LegacyRequest = 1,
     Close = 2,
+    LegacyControl = 3,
     Request = 4,
     Control = 5,
+    RequestWithContext = 6,
+    ControlWithContext = 7,
     Unspecified,
 };
 
@@ -167,6 +172,7 @@ struct DomainMessageHeader {
         struct {
             union {
                 BitField<0, 8, CommandType> command;
+                BitField<8, 8, u32_le> input_object_count;
                 BitField<16, 16, u32_le> size;
             };
             u32_le object_id;

src/core/hle/ipc_helpers.h

@@ -298,6 +298,13 @@ public:
 
     template <typename T>
     Kernel::SharedPtr<T> GetCopyObject(size_t index);
+
+    template <class T>
+    std::shared_ptr<T> PopIpcInterface() {
+        ASSERT(context->Session()->IsDomain());
+        ASSERT(context->GetDomainMessageHeader()->input_object_count > 0);
+        return context->GetDomainRequestHandler<T>(Pop<u32>() - 1);
+    }
 };
 
 /// Pop ///

src/core/hle/kernel/address_arbiter.cpp

@@ -0,0 +1,175 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "core/core.h"
+#include "core/hle/kernel/errors.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/kernel/thread.h"
+#include "core/hle/lock.h"
+#include "core/memory.h"
+
+namespace Kernel {
+namespace AddressArbiter {
+
+// Performs actual address waiting logic.
+static ResultCode WaitForAddress(VAddr address, s64 timeout) {
+    SharedPtr<Thread> current_thread = GetCurrentThread();
+    current_thread->arb_wait_address = address;
+    current_thread->status = THREADSTATUS_WAIT_ARB;
+    current_thread->wakeup_callback = nullptr;
+
+    current_thread->WakeAfterDelay(timeout);
+
+    Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule();
+    return RESULT_TIMEOUT;
+}
+
+// Gets the threads waiting on an address.
+static void GetThreadsWaitingOnAddress(std::vector<SharedPtr<Thread>>& waiting_threads,
+                                       VAddr address) {
+    auto RetrieveWaitingThreads =
+        [](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr arb_addr) {
+            const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
+            auto& thread_list = scheduler->GetThreadList();
+
+            for (auto& thread : thread_list) {
+                if (thread->arb_wait_address == arb_addr)
+                    waiting_threads.push_back(thread);
+            }
+        };
+
+    // Retrieve a list of all threads that are waiting for this address.
+    RetrieveWaitingThreads(0, waiting_threads, address);
+    RetrieveWaitingThreads(1, waiting_threads, address);
+    RetrieveWaitingThreads(2, waiting_threads, address);
+    RetrieveWaitingThreads(3, waiting_threads, address);
+    // Sort them by priority, such that the highest priority ones come first.
+    std::sort(waiting_threads.begin(), waiting_threads.end(),
+              [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
+                  return lhs->current_priority < rhs->current_priority;
+              });
+}
+
+// Wake up num_to_wake (or all) threads in a vector.
+static void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
+    // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
+    // them all.
+    size_t last = waiting_threads.size();
+    if (num_to_wake > 0)
+        last = num_to_wake;
+
+    // Signal the waiting threads.
+    for (size_t i = 0; i < last; i++) {
+        ASSERT(waiting_threads[i]->status = THREADSTATUS_WAIT_ARB);
+        waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
+        waiting_threads[i]->arb_wait_address = 0;
+        waiting_threads[i]->ResumeFromWait();
+    }
+}
+
+// Signals an address being waited on.
+ResultCode SignalToAddress(VAddr address, s32 num_to_wake) {
+    // Get threads waiting on the address.
+    std::vector<SharedPtr<Thread>> waiting_threads;
+    GetThreadsWaitingOnAddress(waiting_threads, address);
+
+    WakeThreads(waiting_threads, num_to_wake);
+    return RESULT_SUCCESS;
+}
+
+// Signals an address being waited on and increments its value if equal to the value argument.
+ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) {
+    // Ensure that we can write to the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    if (static_cast<s32>(Memory::Read32(address)) == value) {
+        Memory::Write32(address, static_cast<u32>(value + 1));
+    } else {
+        return ERR_INVALID_STATE;
+    }
+
+    return SignalToAddress(address, num_to_wake);
+}
+
+// Signals an address being waited on and modifies its value based on waiting thread count if equal
+// to the value argument.
+ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
+                                                         s32 num_to_wake) {
+    // Ensure that we can write to the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    // Get threads waiting on the address.
+    std::vector<SharedPtr<Thread>> waiting_threads;
+    GetThreadsWaitingOnAddress(waiting_threads, address);
+
+    // Determine the modified value depending on the waiting count.
+    s32 updated_value;
+    if (waiting_threads.size() == 0) {
+        updated_value = value - 1;
+    } else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
+        updated_value = value + 1;
+    } else {
+        updated_value = value;
+    }
+
+    if (static_cast<s32>(Memory::Read32(address)) == value) {
+        Memory::Write32(address, static_cast<u32>(updated_value));
+    } else {
+        return ERR_INVALID_STATE;
+    }
+
+    WakeThreads(waiting_threads, num_to_wake);
+    return RESULT_SUCCESS;
+}
+
+// Waits on an address if the value passed is less than the argument value, optionally decrementing.
+ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement) {
+    // Ensure that we can read the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    s32 cur_value = static_cast<s32>(Memory::Read32(address));
+    if (cur_value < value) {
+        if (should_decrement) {
+            Memory::Write32(address, static_cast<u32>(cur_value - 1));
+        }
+    } else {
+        return ERR_INVALID_STATE;
+    }
+    // Short-circuit without rescheduling, if timeout is zero.
+    if (timeout == 0) {
+        return RESULT_TIMEOUT;
+    }
+
+    return WaitForAddress(address, timeout);
+}
+
+// Waits on an address if the value passed is equal to the argument value.
+ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
+    // Ensure that we can read the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+    // Only wait for the address if equal.
+    if (static_cast<s32>(Memory::Read32(address)) != value) {
+        return ERR_INVALID_STATE;
+    }
+    // Short-circuit without rescheduling, if timeout is zero.
+    if (timeout == 0) {
+        return RESULT_TIMEOUT;
+    }
+
+    return WaitForAddress(address, timeout);
+}
+} // namespace AddressArbiter
+} // namespace Kernel

src/core/hle/kernel/address_arbiter.h

@@ -0,0 +1,32 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/result.h"
+
+namespace Kernel {
+
+namespace AddressArbiter {
+enum class ArbitrationType {
+    WaitIfLessThan = 0,
+    DecrementAndWaitIfLessThan = 1,
+    WaitIfEqual = 2,
+};
+
+enum class SignalType {
+    Signal = 0,
+    IncrementAndSignalIfEqual = 1,
+    ModifyByWaitingCountAndSignalIfEqual = 2,
+};
+
+ResultCode SignalToAddress(VAddr address, s32 num_to_wake);
+ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
+ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
+
+ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement);
+ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout);
+} // namespace AddressArbiter
+
+} // namespace Kernel

src/core/hle/kernel/condition_variable.cpp

@@ -1,64 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/hle/kernel/condition_variable.h"
-#include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/object_address_table.h"
-#include "core/hle/kernel/thread.h"
-
-namespace Kernel {
-
-ConditionVariable::ConditionVariable() {}
-ConditionVariable::~ConditionVariable() {}
-
-ResultVal<SharedPtr<ConditionVariable>> ConditionVariable::Create(VAddr guest_addr,
-                                                                  std::string name) {
-    SharedPtr<ConditionVariable> condition_variable(new ConditionVariable);
-
-    condition_variable->name = std::move(name);
-    condition_variable->guest_addr = guest_addr;
-    condition_variable->mutex_addr = 0;
-
-    // Condition variables are referenced by guest address, so track this in the kernel
-    g_object_address_table.Insert(guest_addr, condition_variable);
-
-    return MakeResult<SharedPtr<ConditionVariable>>(std::move(condition_variable));
-}
-
-bool ConditionVariable::ShouldWait(Thread* thread) const {
-    return GetAvailableCount() <= 0;
-}
-
-void ConditionVariable::Acquire(Thread* thread) {
-    if (GetAvailableCount() <= 0)
-        return;
-
-    SetAvailableCount(GetAvailableCount() - 1);
-}
-
-ResultCode ConditionVariable::Release(s32 target) {
-    if (target == -1) {
-        // When -1, wake up all waiting threads
-        SetAvailableCount(static_cast<s32>(GetWaitingThreads().size()));
-        WakeupAllWaitingThreads();
-    } else {
-        // Otherwise, wake up just a single thread
-        SetAvailableCount(target);
-        WakeupWaitingThread(GetHighestPriorityReadyThread());
-    }
-
-    return RESULT_SUCCESS;
-}
-
-s32 ConditionVariable::GetAvailableCount() const {
-    return Memory::Read32(guest_addr);
-}
-
-void ConditionVariable::SetAvailableCount(s32 value) const {
-    Memory::Write32(guest_addr, value);
-}
-
-} // namespace Kernel

src/core/hle/kernel/condition_variable.h

@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <queue>
-#include "common/common_types.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/wait_object.h"
-#include "core/hle/result.h"
-
-namespace Kernel {
-
-class ConditionVariable final : public WaitObject {
-public:
-    /**
-     * Creates a condition variable.
-     * @param guest_addr Address of the object tracking the condition variable in guest memory. If
-     * specified, this condition variable will update the guest object when its state changes.
-     * @param name Optional name of condition variable.
-     * @return The created condition variable.
-     */
-    static ResultVal<SharedPtr<ConditionVariable>> Create(VAddr guest_addr,
-                                                          std::string name = "Unknown");
-
-    std::string GetTypeName() const override {
-        return "ConditionVariable";
-    }
-    std::string GetName() const override {
-        return name;
-    }
-
-    static const HandleType HANDLE_TYPE = HandleType::ConditionVariable;
-    HandleType GetHandleType() const override {
-        return HANDLE_TYPE;
-    }
-
-    s32 GetAvailableCount() const;
-    void SetAvailableCount(s32 value) const;
-
-    std::string name; ///< Name of condition variable (optional)
-    VAddr guest_addr; ///< Address of the guest condition variable value
-    VAddr mutex_addr; ///< (optional) Address of guest mutex value associated with this condition
-                      ///< variable, used for implementing events
-
-    bool ShouldWait(Thread* thread) const override;
-    void Acquire(Thread* thread) override;
-
-    /**
-     * Releases a slot from a condition variable.
-     * @param target The number of threads to wakeup, -1 is all.
-     * @return ResultCode indicating if the operation succeeded.
-     */
-    ResultCode Release(s32 target);
-
-private:
-    ConditionVariable();
-    ~ConditionVariable() override;
-};
-
-} // namespace Kernel

src/core/hle/kernel/errors.h

@@ -20,10 +20,16 @@ enum {
     MaxConnectionsReached = 52,
 
     // Confirmed Switch OS error codes
+    InvalidAddress = 102,
+    InvalidMemoryState = 106,
+    InvalidProcessorId = 113,
     InvalidHandle = 114,
+    InvalidCombination = 116,
     Timeout = 117,
     SynchronizationCanceled = 118,
     TooLarge = 119,
+    InvalidEnumValue = 120,
+    InvalidState = 125,
 };
 }
 
@@ -36,14 +42,15 @@ constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(-1);
 constexpr ResultCode ERR_PORT_NAME_TOO_LONG(-1);
 constexpr ResultCode ERR_WRONG_PERMISSION(-1);
 constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED(-1);
-constexpr ResultCode ERR_INVALID_ENUM_VALUE(-1);
+constexpr ResultCode ERR_INVALID_ENUM_VALUE(ErrorModule::Kernel, ErrCodes::InvalidEnumValue);
 constexpr ResultCode ERR_INVALID_ENUM_VALUE_FND(-1);
 constexpr ResultCode ERR_INVALID_COMBINATION(-1);
 constexpr ResultCode ERR_INVALID_COMBINATION_KERNEL(-1);
 constexpr ResultCode ERR_OUT_OF_MEMORY(-1);
-constexpr ResultCode ERR_INVALID_ADDRESS(-1);
-constexpr ResultCode ERR_INVALID_ADDRESS_STATE(-1);
+constexpr ResultCode ERR_INVALID_ADDRESS(ErrorModule::Kernel, ErrCodes::InvalidAddress);
+constexpr ResultCode ERR_INVALID_ADDRESS_STATE(ErrorModule::Kernel, ErrCodes::InvalidMemoryState);
 constexpr ResultCode ERR_INVALID_HANDLE(ErrorModule::Kernel, ErrCodes::InvalidHandle);
+constexpr ResultCode ERR_INVALID_STATE(ErrorModule::Kernel, ErrCodes::InvalidState);
 constexpr ResultCode ERR_INVALID_POINTER(-1);
 constexpr ResultCode ERR_INVALID_OBJECT_ADDR(-1);
 constexpr ResultCode ERR_NOT_AUTHORIZED(-1);

src/core/hle/kernel/handle_table.cpp

@@ -48,7 +48,7 @@ ResultVal<Handle> HandleTable::Create(SharedPtr<Object> obj) {
 ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
     SharedPtr<Object> object = GetGeneric(handle);
     if (object == nullptr) {
-        LOG_ERROR(Kernel, "Tried to duplicate invalid handle: %08X", handle);
+        LOG_ERROR(Kernel, "Tried to duplicate invalid handle: {:08X}", handle);
         return ERR_INVALID_HANDLE;
     }
     return Create(std::move(object));

src/core/hle/kernel/hle_ipc.cpp

@@ -29,7 +29,8 @@ void SessionRequestHandler::ClientDisconnected(SharedPtr<ServerSession> server_s
 
 SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
                                                       const std::string& reason, u64 timeout,
-                                                      WakeupCallback&& callback) {
+                                                      WakeupCallback&& callback,
+                                                      Kernel::SharedPtr<Kernel::Event> event) {
 
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
     thread->wakeup_callback =
@@ -41,7 +42,12 @@ SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
         return true;
     };
 
-    auto event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
+    if (!event) {
+        // Create event if not provided
+        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
+    }
+
+    event->Clear();
     thread->status = THREADSTATUS_WAIT_HLE_EVENT;
     thread->wait_objects = {event};
     event->AddWaitingThread(thread);
@@ -110,7 +116,9 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     // Padding to align to 16 bytes
     rp.AlignWithPadding();
 
-    if (Session()->IsDomain() && (command_header->type == IPC::CommandType::Request || !incoming)) {
+    if (Session()->IsDomain() && ((command_header->type == IPC::CommandType::Request ||
+                                   command_header->type == IPC::CommandType::RequestWithContext) ||
+                                  !incoming)) {
         // If this is an incoming message, only CommandType "Request" has a domain header
         // All outgoing domain messages have the domain header, if only incoming has it
         if (incoming || domain_message_header) {
@@ -212,8 +220,8 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
             (sizeof(IPC::CommandHeader) + sizeof(IPC::HandleDescriptorHeader)) / sizeof(u32);
         ASSERT_MSG(!handle_descriptor_header->send_current_pid, "Sending PID is not implemented");
 
-        ASSERT_MSG(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
-        ASSERT_MSG(move_objects.size() == handle_descriptor_header->num_handles_to_move);
+        ASSERT(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
+        ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);
 
         // We don't make a distinction between copy and move handles when translating since HLE
         // services don't deal with handles directly. However, the guest applications might check
@@ -251,50 +259,60 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
     return RESULT_SUCCESS;
 }
 
-std::vector<u8> HLERequestContext::ReadBuffer() const {
+std::vector<u8> HLERequestContext::ReadBuffer(int buffer_index) const {
     std::vector<u8> buffer;
-    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[0].Size()};
+    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[buffer_index].Size()};
 
     if (is_buffer_a) {
-        buffer.resize(BufferDescriptorA()[0].Size());
-        Memory::ReadBlock(BufferDescriptorA()[0].Address(), buffer.data(), buffer.size());
+        buffer.resize(BufferDescriptorA()[buffer_index].Size());
+        Memory::ReadBlock(BufferDescriptorA()[buffer_index].Address(), buffer.data(),
+                          buffer.size());
     } else {
-        buffer.resize(BufferDescriptorX()[0].Size());
-        Memory::ReadBlock(BufferDescriptorX()[0].Address(), buffer.data(), buffer.size());
+        buffer.resize(BufferDescriptorX()[buffer_index].Size());
+        Memory::ReadBlock(BufferDescriptorX()[buffer_index].Address(), buffer.data(),
+                          buffer.size());
     }
 
     return buffer;
 }
 
-size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size) const {
-    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
-    const size_t buffer_size{GetWriteBufferSize()};
+size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size, int buffer_index) const {
+    if (size == 0) {
+        LOG_WARNING(Core, "skip empty buffer write");
+        return 0;
+    }
+
+    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[buffer_index].Size()};
+    const size_t buffer_size{GetWriteBufferSize(buffer_index)};
     if (size > buffer_size) {
-        LOG_CRITICAL(Core, "size (%016zx) is greater than buffer_size (%016zx)", size, buffer_size);
+        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
+                     buffer_size);
         size = buffer_size; // TODO(bunnei): This needs to be HW tested
     }
 
     if (is_buffer_b) {
-        Memory::WriteBlock(BufferDescriptorB()[0].Address(), buffer, size);
+        Memory::WriteBlock(BufferDescriptorB()[buffer_index].Address(), buffer, size);
     } else {
-        Memory::WriteBlock(BufferDescriptorC()[0].Address(), buffer, size);
+        Memory::WriteBlock(BufferDescriptorC()[buffer_index].Address(), buffer, size);
     }
 
     return size;
 }
 
-size_t HLERequestContext::WriteBuffer(const std::vector<u8>& buffer) const {
+size_t HLERequestContext::WriteBuffer(const std::vector<u8>& buffer, int buffer_index) const {
     return WriteBuffer(buffer.data(), buffer.size());
 }
 
-size_t HLERequestContext::GetReadBufferSize() const {
-    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[0].Size()};
-    return is_buffer_a ? BufferDescriptorA()[0].Size() : BufferDescriptorX()[0].Size();
+size_t HLERequestContext::GetReadBufferSize(int buffer_index) const {
+    const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[buffer_index].Size()};
+    return is_buffer_a ? BufferDescriptorA()[buffer_index].Size()
+                       : BufferDescriptorX()[buffer_index].Size();
 }
 
-size_t HLERequestContext::GetWriteBufferSize() const {
-    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
-    return is_buffer_b ? BufferDescriptorB()[0].Size() : BufferDescriptorC()[0].Size();
+size_t HLERequestContext::GetWriteBufferSize(int buffer_index) const {
+    const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[buffer_index].Size()};
+    return is_buffer_b ? BufferDescriptorB()[buffer_index].Size()
+                       : BufferDescriptorC()[buffer_index].Size();
 }
 
 std::string HLERequestContext::Description() const {

src/core/hle/kernel/hle_ipc.h

@@ -118,10 +118,12 @@ public:
      * @param callback Callback to be invoked when the thread is resumed. This callback must write
      * the entire command response once again, regardless of the state of it before this function
      * was called.
+     * @param event Event to use to wake up the thread. If unspecified, an event will be created.
      * @returns Event that when signaled will resume the thread and call the callback function.
      */
     SharedPtr<Event> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
-                                       u64 timeout, WakeupCallback&& callback);
+                                       u64 timeout, WakeupCallback&& callback,
+                                       Kernel::SharedPtr<Kernel::Event> event = nullptr);
 
     void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
 
@@ -164,19 +166,19 @@ public:
     }
 
     /// Helper function to read a buffer using the appropriate buffer descriptor
-    std::vector<u8> ReadBuffer() const;
+    std::vector<u8> ReadBuffer(int buffer_index = 0) const;
 
     /// Helper function to write a buffer using the appropriate buffer descriptor
-    size_t WriteBuffer(const void* buffer, size_t size) const;
+    size_t WriteBuffer(const void* buffer, size_t size, int buffer_index = 0) const;
 
     /// Helper function to write a buffer using the appropriate buffer descriptor
-    size_t WriteBuffer(const std::vector<u8>& buffer) const;
+    size_t WriteBuffer(const std::vector<u8>& buffer, int buffer_index = 0) const;
 
     /// Helper function to get the size of the input buffer
-    size_t GetReadBufferSize() const;
+    size_t GetReadBufferSize(int buffer_index = 0) const;
 
     /// Helper function to get the size of the output buffer
-    size_t GetWriteBufferSize() const;
+    size_t GetWriteBufferSize(int buffer_index = 0) const;
 
     template <typename T>
     SharedPtr<T> GetCopyObject(size_t index) {
@@ -202,6 +204,16 @@ public:
         domain_objects.emplace_back(std::move(object));
     }
 
+    template <typename T>
+    std::shared_ptr<T> GetDomainRequestHandler(size_t index) const {
+        return std::static_pointer_cast<T>(domain_request_handlers[index]);
+    }
+
+    void SetDomainRequestHandlers(
+        const std::vector<std::shared_ptr<SessionRequestHandler>>& handlers) {
+        domain_request_handlers = handlers;
+    }
+
     /// Clears the list of objects so that no lingering objects are written accidentally to the
     /// response buffer.
     void ClearIncomingObjects() {
@@ -245,6 +257,8 @@ private:
     unsigned data_payload_offset{};
     unsigned buffer_c_offset{};
     u32_le command{};
+
+    std::vector<std::shared_ptr<SessionRequestHandler>> domain_request_handlers;
 };
 
 } // namespace Kernel

src/core/hle/kernel/kernel.h

@@ -18,12 +18,10 @@ using Handle = u32;
 enum class HandleType : u32 {
     Unknown,
     Event,
-    Mutex,
     SharedMemory,
     Thread,
     Process,
     AddressArbiter,
-    ConditionVariable,
     Timer,
     ResourceLimit,
     CodeSet,
@@ -63,9 +61,7 @@ public:
     bool IsWaitable() const {
         switch (GetHandleType()) {
         case HandleType::Event:
-        case HandleType::Mutex:
         case HandleType::Thread:
-        case HandleType::ConditionVariable:
         case HandleType::Timer:
         case HandleType::ServerPort:
         case HandleType::ServerSession:

src/core/hle/kernel/mutex.cpp

@@ -7,6 +7,7 @@
 #include <boost/range/algorithm_ext/erase.hpp>
 #include "common/assert.h"
 #include "core/core.h"
+#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
@@ -15,124 +16,119 @@
 
 namespace Kernel {
 
-void ReleaseThreadMutexes(Thread* thread) {
-    for (auto& mtx : thread->held_mutexes) {
-        mtx->SetHasWaiters(false);
-        mtx->SetHoldingThread(nullptr);
-        mtx->WakeupAllWaitingThreads();
-    }
-    thread->held_mutexes.clear();
-}
+/// Returns the number of threads that are waiting for a mutex, and the highest priority one among
+/// those.
+static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
+    SharedPtr<Thread> current_thread, VAddr mutex_addr) {
 
-Mutex::Mutex() {}
-Mutex::~Mutex() {}
+    SharedPtr<Thread> highest_priority_thread;
+    u32 num_waiters = 0;
 
-SharedPtr<Mutex> Mutex::Create(SharedPtr<Kernel::Thread> holding_thread, VAddr guest_addr,
-                               std::string name) {
-    SharedPtr<Mutex> mutex(new Mutex);
+    for (auto& thread : current_thread->wait_mutex_threads) {
+        if (thread->mutex_wait_address != mutex_addr)
+            continue;
 
-    mutex->guest_addr = guest_addr;
-    mutex->name = std::move(name);
+        ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
 
-    // If mutex was initialized with a holding thread, acquire it by the holding thread
-    if (holding_thread) {
-        mutex->Acquire(holding_thread.get());
+        ++num_waiters;
+        if (highest_priority_thread == nullptr ||
+            thread->GetPriority() < highest_priority_thread->GetPriority()) {
+            highest_priority_thread = thread;
+        }
     }
 
-    // Mutexes are referenced by guest address, so track this in the kernel
-    g_object_address_table.Insert(guest_addr, mutex);
-
-    return mutex;
+    return {highest_priority_thread, num_waiters};
 }
 
-bool Mutex::ShouldWait(Thread* thread) const {
-    auto holding_thread = GetHoldingThread();
-    return holding_thread != nullptr && thread != holding_thread;
+/// Update the mutex owner field of all threads waiting on the mutex to point to the new owner.
+static void TransferMutexOwnership(VAddr mutex_addr, SharedPtr<Thread> current_thread,
+                                   SharedPtr<Thread> new_owner) {
+    auto threads = current_thread->wait_mutex_threads;
+    for (auto& thread : threads) {
+        if (thread->mutex_wait_address != mutex_addr)
+            continue;
+
+        ASSERT(thread->lock_owner == current_thread);
+        current_thread->RemoveMutexWaiter(thread);
+        if (new_owner != thread)
+            new_owner->AddMutexWaiter(thread);
+    }
 }
 
-void Mutex::Acquire(Thread* thread) {
-    ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
+ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
+                             Handle requesting_thread_handle) {
+    // The mutex address must be 4-byte aligned
+    if ((address % sizeof(u32)) != 0) {
+        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidAddress);
+    }
 
-    priority = thread->current_priority;
-    thread->held_mutexes.insert(this);
-    SetHoldingThread(thread);
-    thread->UpdatePriority();
-    Core::System::GetInstance().PrepareReschedule();
-}
+    SharedPtr<Thread> holding_thread = g_handle_table.Get<Thread>(holding_thread_handle);
+    SharedPtr<Thread> requesting_thread = g_handle_table.Get<Thread>(requesting_thread_handle);
 
-ResultCode Mutex::Release(Thread* thread) {
-    auto holding_thread = GetHoldingThread();
-    ASSERT(holding_thread);
+    // TODO(Subv): It is currently unknown if it is possible to lock a mutex in behalf of another
+    // thread.
+    ASSERT(requesting_thread == GetCurrentThread());
 
-    // We can only release the mutex if it's held by the calling thread.
-    ASSERT(thread == holding_thread);
+    u32 addr_value = Memory::Read32(address);
+
+    // If the mutex isn't being held, just return success.
+    if (addr_value != (holding_thread_handle | Mutex::MutexHasWaitersFlag)) {
+        return RESULT_SUCCESS;
+    }
+
+    if (holding_thread == nullptr)
+        return ERR_INVALID_HANDLE;
+
+    // Wait until the mutex is released
+    GetCurrentThread()->mutex_wait_address = address;
+    GetCurrentThread()->wait_handle = requesting_thread_handle;
+
+    GetCurrentThread()->status = THREADSTATUS_WAIT_MUTEX;
+    GetCurrentThread()->wakeup_callback = nullptr;
+
+    // Update the lock holder thread's priority to prevent priority inversion.
+    holding_thread->AddMutexWaiter(GetCurrentThread());
 
-    holding_thread->held_mutexes.erase(this);
-    holding_thread->UpdatePriority();
-    SetHoldingThread(nullptr);
-    SetHasWaiters(!GetWaitingThreads().empty());
-    WakeupAllWaitingThreads();
     Core::System::GetInstance().PrepareReschedule();
 
     return RESULT_SUCCESS;
 }
 
-void Mutex::AddWaitingThread(SharedPtr<Thread> thread) {
-    WaitObject::AddWaitingThread(thread);
-    thread->pending_mutexes.insert(this);
-    SetHasWaiters(true);
-    UpdatePriority();
-}
-
-void Mutex::RemoveWaitingThread(Thread* thread) {
-    WaitObject::RemoveWaitingThread(thread);
-    thread->pending_mutexes.erase(this);
-    if (!GetHasWaiters())
-        SetHasWaiters(!GetWaitingThreads().empty());
-    UpdatePriority();
-}
-
-void Mutex::UpdatePriority() {
-    if (!GetHoldingThread())
-        return;
-
-    u32 best_priority = THREADPRIO_LOWEST;
-    for (auto& waiter : GetWaitingThreads()) {
-        if (waiter->current_priority < best_priority)
-            best_priority = waiter->current_priority;
+ResultCode Mutex::Release(VAddr address) {
+    // The mutex address must be 4-byte aligned
+    if ((address % sizeof(u32)) != 0) {
+        return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidAddress);
     }
 
-    if (best_priority != priority) {
-        priority = best_priority;
-        GetHoldingThread()->UpdatePriority();
+    auto [thread, num_waiters] = GetHighestPriorityMutexWaitingThread(GetCurrentThread(), address);
+
+    // There are no more threads waiting for the mutex, release it completely.
+    if (thread == nullptr) {
+        Memory::Write32(address, 0);
+        return RESULT_SUCCESS;
     }
-}
 
-Handle Mutex::GetOwnerHandle() const {
-    GuestState guest_state{Memory::Read32(guest_addr)};
-    return guest_state.holding_thread_handle;
-}
+    // Transfer the ownership of the mutex from the previous owner to the new one.
+    TransferMutexOwnership(address, GetCurrentThread(), thread);
 
-SharedPtr<Thread> Mutex::GetHoldingThread() const {
-    GuestState guest_state{Memory::Read32(guest_addr)};
-    return g_handle_table.Get<Thread>(guest_state.holding_thread_handle);
-}
+    u32 mutex_value = thread->wait_handle;
 
-void Mutex::SetHoldingThread(SharedPtr<Thread> thread) {
-    GuestState guest_state{Memory::Read32(guest_addr)};
-    guest_state.holding_thread_handle.Assign(thread ? thread->guest_handle : 0);
-    Memory::Write32(guest_addr, guest_state.raw);
-}
+    if (num_waiters >= 2) {
+        // Notify the guest that there are still some threads waiting for the mutex
+        mutex_value |= Mutex::MutexHasWaitersFlag;
+    }
 
-bool Mutex::GetHasWaiters() const {
-    GuestState guest_state{Memory::Read32(guest_addr)};
-    return guest_state.has_waiters != 0;
-}
+    // Grant the mutex to the next waiting thread and resume it.
+    Memory::Write32(address, mutex_value);
 
-void Mutex::SetHasWaiters(bool has_waiters) {
-    GuestState guest_state{Memory::Read32(guest_addr)};
-    guest_state.has_waiters.Assign(has_waiters ? 1 : 0);
-    Memory::Write32(guest_addr, guest_state.raw);
-}
+    ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
+    thread->ResumeFromWait();
 
+    thread->lock_owner = nullptr;
+    thread->condvar_wait_address = 0;
+    thread->mutex_wait_address = 0;
+    thread->wait_handle = 0;
+
+    return RESULT_SUCCESS;
+}
 } // namespace Kernel

src/core/hle/kernel/mutex.h

@@ -15,87 +15,23 @@ namespace Kernel {
 
 class Thread;
 
-class Mutex final : public WaitObject {
+class Mutex final {
 public:
-    /**
-     * Creates a mutex.
-     * @param holding_thread Specifies a thread already holding the mutex. If not nullptr, this
-     * thread will acquire the mutex.
-     * @param guest_addr Address of the object tracking the mutex in guest memory. If specified,
-     * this mutex will update the guest object when its state changes.
-     * @param name Optional name of mutex
-     * @return Pointer to new Mutex object
-     */
-    static SharedPtr<Mutex> Create(SharedPtr<Kernel::Thread> holding_thread, VAddr guest_addr = 0,
-                                   std::string name = "Unknown");
+    /// Flag that indicates that a mutex still has threads waiting for it.
+    static constexpr u32 MutexHasWaitersFlag = 0x40000000;
+    /// Mask of the bits in a mutex address value that contain the mutex owner.
+    static constexpr u32 MutexOwnerMask = 0xBFFFFFFF;
 
-    std::string GetTypeName() const override {
-        return "Mutex";
-    }
-    std::string GetName() const override {
-        return name;
-    }
+    /// Attempts to acquire a mutex at the specified address.
+    static ResultCode TryAcquire(VAddr address, Handle holding_thread_handle,
+                                 Handle requesting_thread_handle);
 
-    static const HandleType HANDLE_TYPE = HandleType::Mutex;
-    HandleType GetHandleType() const override {
-        return HANDLE_TYPE;
-    }
-
-    u32 priority;     ///< The priority of the mutex, used for priority inheritance.
-    std::string name; ///< Name of mutex (optional)
-    VAddr guest_addr; ///< Address of the guest mutex value
-
-    /**
-     * Elevate the mutex priority to the best priority
-     * among the priorities of all its waiting threads.
-     */
-    void UpdatePriority();
-
-    bool ShouldWait(Thread* thread) const override;
-    void Acquire(Thread* thread) override;
-
-    void AddWaitingThread(SharedPtr<Thread> thread) override;
-    void RemoveWaitingThread(Thread* thread) override;
-
-    /**
-     * Attempts to release the mutex from the specified thread.
-     * @param thread Thread that wants to release the mutex.
-     * @returns The result code of the operation.
-     */
-    ResultCode Release(Thread* thread);
-
-    /// Gets the handle to the holding process stored in the guest state.
-    Handle GetOwnerHandle() const;
-
-    /// Gets the Thread pointed to by the owner handle
-    SharedPtr<Thread> GetHoldingThread() const;
-    /// Sets the holding process handle in the guest state.
-    void SetHoldingThread(SharedPtr<Thread> thread);
-
-    /// Returns the has_waiters bit in the guest state.
-    bool GetHasWaiters() const;
-    /// Sets the has_waiters bit in the guest state.
-    void SetHasWaiters(bool has_waiters);
+    /// Releases the mutex at the specified address.
+    static ResultCode Release(VAddr address);
 
 private:
-    Mutex();
-    ~Mutex() override;
-
-    /// Object in guest memory used to track the mutex state
-    union GuestState {
-        u32_le raw;
-        /// Handle of the thread that currently holds the mutex, 0 if available
-        BitField<0, 30, u32_le> holding_thread_handle;
-        /// 1 when there are threads waiting for this mutex, otherwise 0
-        BitField<30, 1, u32_le> has_waiters;
-    };
-    static_assert(sizeof(GuestState) == 4, "GuestState size is incorrect");
+    Mutex() = default;
+    ~Mutex() = default;
 };
 
-/**
- * Releases all the mutexes held by the specified thread
- * @param thread Thread that is holding the mutexes
- */
-void ReleaseThreadMutexes(Thread* thread);
-
 } // namespace Kernel

src/core/hle/kernel/object_address_table.cpp

@@ -10,12 +10,12 @@ namespace Kernel {
 ObjectAddressTable g_object_address_table;
 
 void ObjectAddressTable::Insert(VAddr addr, SharedPtr<Object> obj) {
-    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x%lx", addr);
+    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x{:X}", addr);
     objects[addr] = obj;
 }
 
 void ObjectAddressTable::Close(VAddr addr) {
-    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x%lx", addr);
+    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x{:X}", addr);
     objects.erase(addr);
 }
 

src/core/hle/kernel/process.cpp

@@ -109,9 +109,9 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
 
             int minor = kernel_version & 0xFF;
             int major = (kernel_version >> 8) & 0xFF;
-            LOG_INFO(Loader, "ExHeader kernel version: %d.%d", major, minor);
+            LOG_INFO(Loader, "ExHeader kernel version: {}.{}", major, minor);
         } else {
-            LOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x%08X", descriptor);
+            LOG_ERROR(Loader, "Unhandled kernel caps descriptor: 0x{:08X}", descriptor);
         }
     }
 }
@@ -134,7 +134,7 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
         HandleSpecialMapping(vm_manager, mapping);
     }
 
-    vm_manager.LogLayout(Log::Level::Debug);
+    vm_manager.LogLayout();
     status = ProcessStatus::Running;
 
     Kernel::SetupMainThread(entry_point, main_thread_priority, this);

src/core/hle/kernel/resource_limit.cpp

@@ -34,57 +34,57 @@ SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory cat
     }
 }
 
-s32 ResourceLimit::GetCurrentResourceValue(u32 resource) const {
+s32 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {
     switch (resource) {
-    case COMMIT:
+    case ResourceType::Commit:
         return current_commit;
-    case THREAD:
+    case ResourceType::Thread:
         return current_threads;
-    case EVENT:
+    case ResourceType::Event:
         return current_events;
-    case MUTEX:
+    case ResourceType::Mutex:
         return current_mutexes;
-    case SEMAPHORE:
+    case ResourceType::Semaphore:
         return current_semaphores;
-    case TIMER:
+    case ResourceType::Timer:
         return current_timers;
-    case SHARED_MEMORY:
+    case ResourceType::SharedMemory:
         return current_shared_mems;
-    case ADDRESS_ARBITER:
+    case ResourceType::AddressArbiter:
         return current_address_arbiters;
-    case CPU_TIME:
+    case ResourceType::CPUTime:
         return current_cpu_time;
     default:
-        LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
+        LOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
         UNIMPLEMENTED();
         return 0;
     }
 }
 
-u32 ResourceLimit::GetMaxResourceValue(u32 resource) const {
+u32 ResourceLimit::GetMaxResourceValue(ResourceType resource) const {
     switch (resource) {
-    case PRIORITY:
+    case ResourceType::Priority:
         return max_priority;
-    case COMMIT:
+    case ResourceType::Commit:
         return max_commit;
-    case THREAD:
+    case ResourceType::Thread:
         return max_threads;
-    case EVENT:
+    case ResourceType::Event:
         return max_events;
-    case MUTEX:
+    case ResourceType::Mutex:
         return max_mutexes;
-    case SEMAPHORE:
+    case ResourceType::Semaphore:
         return max_semaphores;
-    case TIMER:
+    case ResourceType::Timer:
         return max_timers;
-    case SHARED_MEMORY:
+    case ResourceType::SharedMemory:
         return max_shared_mems;
-    case ADDRESS_ARBITER:
+    case ResourceType::AddressArbiter:
         return max_address_arbiters;
-    case CPU_TIME:
+    case ResourceType::CPUTime:
         return max_cpu_time;
     default:
-        LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
+        LOG_ERROR(Kernel, "Unknown resource type={:08X}", static_cast<u32>(resource));
         UNIMPLEMENTED();
         return 0;
     }

src/core/hle/kernel/resource_limit.h

@@ -16,17 +16,17 @@ enum class ResourceLimitCategory : u8 {
     OTHER = 3
 };
 
-enum ResourceTypes {
-    PRIORITY = 0,
-    COMMIT = 1,
-    THREAD = 2,
-    EVENT = 3,
-    MUTEX = 4,
-    SEMAPHORE = 5,
-    TIMER = 6,
-    SHARED_MEMORY = 7,
-    ADDRESS_ARBITER = 8,
-    CPU_TIME = 9,
+enum class ResourceType {
+    Priority = 0,
+    Commit = 1,
+    Thread = 2,
+    Event = 3,
+    Mutex = 4,
+    Semaphore = 5,
+    Timer = 6,
+    SharedMemory = 7,
+    AddressArbiter = 8,
+    CPUTime = 9,
 };
 
 class ResourceLimit final : public Object {
@@ -60,14 +60,14 @@ public:
      * @param resource Requested resource type
      * @returns The current value of the resource type
      */
-    s32 GetCurrentResourceValue(u32 resource) const;
+    s32 GetCurrentResourceValue(ResourceType resource) const;
 
     /**
      * Gets the max value for the specified resource.
      * @param resource Requested resource type
      * @returns The max value of the resource type
      */
-    u32 GetMaxResourceValue(u32 resource) const;
+    u32 GetMaxResourceValue(ResourceType resource) const;
 
     /// Name of resource limit object.
     std::string name;